Changeset 3150 for icXML/icXML-devel


Ignore:
Timestamp:
May 17, 2013, 5:41:20 AM (6 years ago)
Author:
cameron
Message:

Updates for various icxercesc modified files.

Location:
icXML/icXML-devel/src/icxercesc
Files:
27 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/icxercesc/framework/XMLAttDef.hpp

    r2721 r3150  
    412412        void cleanUp();
    413413
    414 
     414protected :
    415415        // -----------------------------------------------------------------------
    416416        //  Private data members
  • icXML/icXML-devel/src/icxercesc/framework/XMLElementDecl.cpp

    r3103 r3150  
    5151XMLElementDecl::~XMLElementDecl()
    5252{
    53     if (fElementName) delete fElementName;
     53    cleanUp();
    5454}
    5555
     
    5858// ---------------------------------------------------------------------------
    5959void
    60 XMLElementDecl::setElementName(const XMLCh* const       prefix
    61                                                         , const XMLCh* const        localPart
    62                                                         , const int                 uriId )
     60XMLElementDecl::setElementName(const XMLCh* const prefix, const XMLCh* const localPart, const int uriId )
    6361{
     62    cleanUp();
    6463        fElementName = new (fMemoryManager) QName(prefix, localPart, uriId, fMemoryManager);
    6564        fUriId = uriId;
     
    6766
    6867void
    69 XMLElementDecl::setElementName(const XMLCh* const       rawName
    70                                                         , const int                 uriId )
     68XMLElementDecl::setElementName(const XMLCh* const rawName, const int uriId)
    7169{
     70    cleanUp();
    7271        fElementName = new (fMemoryManager) QName(rawName, uriId, fMemoryManager);
    7372        fUriId = uriId;
    7473}
    7574
    76 void
    77 XMLElementDecl::setElementName(const QName* const elementName)
     75void XMLElementDecl::setElementName(const QName* const elementName)
    7876{
    79         fElementName = const_cast<QName*>(elementName);
     77    cleanUp();
     78    fElementName = new QName(*elementName);
    8079        fUriId = elementName->getURI();
    8180}
     
    8584// ---------------------------------------------------------------------------
    8685XMLElementDecl::XMLElementDecl(MemoryManager* const manager) :
    87 
    88         fMemoryManager(manager)
    89         , fElementName(0)
    90         , fCreateReason(XMLElementDecl::NoReason)
    91         , fId(XMLElementDecl::fgInvalidElemId)
    92         , fExternalElement(false)
     86fMemoryManager(manager)
     87, fElementName(0)
     88, fCreateReason(XMLElementDecl::NoReason)
     89, fId(XMLElementDecl::fgInvalidElemId)
     90, fExternalElement(false)
    9391{
    9492
     
    10199IMPL_XSERIALIZABLE_NOCREATE(XMLElementDecl)
    102100
    103 void XMLElementDecl::serialize(XSerializeEngine& serEng)
     101void XMLElementDecl::serialize(XSerializeEngine&)
    104102{
    105 #if 0
    106         if (serEng.isStoring())
    107         {
    108                 serEng<<fElementName;
    109                 serEng<<(int) fCreateReason;
    110                 serEng.writeSize (fId);
    111                 serEng<<fExternalElement;
    112         }
    113         else
    114         {
    115                 serEng>>fElementName;
    116 
    117                 int i;
    118                 serEng>>i;
    119                 fCreateReason=(CreateReasons)i;
    120 
    121                 serEng.readSize (fId);
    122                 serEng>>fExternalElement;
    123         }
    124 #else
    125         DEPRECATED_FEATURE_IN_ICXML;
    126 #endif
     103    DEPRECATED_FEATURE_IN_ICXML;
    127104}
    128105
    129106void
    130 XMLElementDecl::storeElementDecl(XSerializeEngine&        serEng
    131                                                            , XMLElementDecl*    const element)
     107XMLElementDecl::storeElementDecl(XSerializeEngine&, XMLElementDecl* const)
    132108{
    133 #if 0
    134         if (element)
    135         {
    136                 serEng<<(int) element->getObjectType();
    137                 serEng<<element;
    138         }
    139         else
    140         {
    141                 serEng<<(int) UnKnown;
    142         }
    143 #else
    144         DEPRECATED_FEATURE_IN_ICXML;
    145 #endif
     109    DEPRECATED_FEATURE_IN_ICXML;
    146110}
    147111
    148 XMLElementDecl*
    149 XMLElementDecl::loadElementDecl(XSerializeEngine& serEng)
     112XMLElementDecl* XMLElementDecl::loadElementDecl(XSerializeEngine&)
    150113{
    151 #if 0
    152         int type;
    153         serEng>>type;
    154 
    155         switch((XMLElementDecl::objectType)type)
    156         {
    157           case Schema:
    158                   SchemaElementDecl* schemaElementDecl;
    159                   serEng>>schemaElementDecl;
    160                   return schemaElementDecl;
    161           case DTD:
    162                   DTDElementDecl* dtdElementDecl;
    163                   serEng>>dtdElementDecl;
    164                   return dtdElementDecl;
    165           case UnKnown:
    166                    //fall through
    167           default:
    168                   return 0;
    169         }
    170 #else
    171         DEPRECATED_FEATURE_IN_ICXML;
    172 #endif
     114    DEPRECATED_FEATURE_IN_ICXML;
    173115}
    174116
  • icXML/icXML-devel/src/icxercesc/framework/XMLElementDecl.hpp

    r3103 r3150  
    451451
    452452
     453    inline void cleanUp();
     454private:
    453455        // -----------------------------------------------------------------------
    454456        //  Data members
     
    578580{
    579581        fExternalElement = aValue;
     582}
     583
     584inline void XMLElementDecl::cleanUp()
     585{
     586    delete fElementName;
    580587}
    581588
  • icXML/icXML-devel/src/icxercesc/internal/IGXMLScanner.cpp

    r3104 r3150  
    8080        , fCachedSchemaInfoList (0)
    8181    , fAnySimpleTypeValidator(0)
    82         , fProgressiveParser(0)
    8382{
    8483        CleanupType cleanup(this, &IGXMLScanner::cleanUp);
     
    128127        , fCachedSchemaInfoList (0)
    129128    , fAnySimpleTypeValidator(0)
    130         , fProgressiveParser(0)
    131129{
    132130        CleanupType cleanup(this, &IGXMLScanner::cleanUp);
     
    271269void IGXMLScanner::scanFirst()
    272270{
    273         fProgressiveParser = fReaderMgr.getCurrentReader()->scanFirst<IGXMLScanner>(this);
    274 }
    275 
    276 bool IGXMLScanner::scanNext(XMLPScanToken& token)
     271    fReaderMgr.getCurrentReader()->scanFirst<IGXMLScanner>(this);
     272}
     273
     274bool IGXMLScanner::scanNext(XMLPScanToken & token)
    277275{
    278276        // Make sure this token is still legal
    279         if (!isLegalToken(token))
     277    if (unlikely(!isLegalToken(token)))
    280278                ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Scan_BadPScanToken, fMemoryManager);
    281279
    282280        try
    283281        {
    284                 const bool gotData =
    285                         fReaderMgr.getCurrentReader()->scanNext<IGXMLScanner>(*fProgressiveParser);
    286 
    287282                // If we hit the end, then do the miscellaneous part
    288                 if (!gotData)
    289                 {
    290                         // Do post-parse validation if required
    291                         if (fValidate)
    292                         {
    293                                 //  We handle ID reference semantics at this level since
    294                                 //  its required by XML 1.0.
    295                                 checkIDRefs();
    296                         }
    297 
    298                         if (toCheckIdentityConstraint())
    299                                 fICHandler->endDocument();
    300 
    301                         if (fDocHandler)
    302                                 fDocHandler->endDocument();
    303                 }
    304 
    305                 return gotData;
     283        if (likely(fReaderMgr.getCurrentReader()->scanNext<IGXMLScanner>()))
     284                {
     285            return true;
     286        }
     287
     288        // Do post-parse validation if required
     289        if (fValidate)
     290        {
     291            //  We handle ID reference semantics at this level since
     292            //  its required by XML 1.0.
     293            checkIDRefs();
     294        }
     295
     296        if (toCheckIdentityConstraint())
     297            fICHandler->endDocument();
     298
     299        if (fDocHandler)
     300            fDocHandler->endDocument();
    306301        }
    307302        catch(const XMLErrs::Codes)
     
    335330                                );
    336331                        else
    337                                 emitError
    338                                 (
    339                                         XMLErrs::XMLException_Error
    340                                         , excToCatch.getCode()
    341                                         , excToCatch.getMessage()
    342                                 );
     332                                emitError(XMLErrs::XMLException_Error, excToCatch.getCode(), excToCatch.getMessage());
    343333                }
    344334                catch(const OutOfMemoryException&)
     
    417407        delete fSchemaInfoList;
    418408        delete fCachedSchemaInfoList;
    419         delete fProgressiveParser;
    420409}
    421410
     
    433422{
    434423    //  We have a doc type. So, switch the Grammar.
    435     switchGrammar(XMLUni::fgDTDEntityString);
     424    switchGrammar(XMLNamespaceResolver::fEmptyUriId, XMLUni::fgDTDEntityString);
     425    // setCurrentGrammar(fGrammarResolver->getGrammar(XMLUni::fgDTDEntityString));
    436426
    437427    if (fDocTypeHandler)
     
    602592    {
    603593        // Eat the opening square bracket
    604         fReaderMgr.getNextChar();
     594        XMLCh openSquareBracket = fReaderMgr.getNextChar();
     595        assert (openSquareBracket == chOpenSquare);
    605596
    606597        checkInternalDTD(hasExtSubset, sysId, pubId);
     
    12621253    , XMLBuffer &                   toFill
    12631254    , bool      &                   isPredefined
    1264     , XMLReader::XMLVersion &       version
     1255    , bool      &                   isExternal
    12651256    , XMLFileLoc &                  line
    12661257    , XMLFileLoc &                  column
     
    13711362        line = reader->getLineNumber();
    13721363        column = reader->getColumnNumber();
    1373         version = reader->getXMLVersion();       
     1364        isExternal = true;
    13741365        // now obtain the entire the value
    13751366        reader->fill(toFill);
    1376 
    1377         fReaderMgr.popReader();
    13781367        }
    13791368        else // internal entity
    13801369        {
    1381         version = this->getXMLVersion();
    1382 
    13831370                //  If its a predefined entity reference...
    13841371                if (decl->getIsSpecialChar())
     
    13891376        else
    13901377        {
     1378            // line  = 0;
     1379            // column = 0;
    13911380            toFill.set(decl->getValue(), decl->getValueLen());
    13921381        }
     
    13951384}
    13961385
     1386
     1387
     1388void IGXMLScanner::reportRequiredAttribute(const DTDAttDef & attDef)
     1389{
     1390    XMLBufBid bbAttName(&fBufMgr);
     1391    XMLBuffer & bAttName = bbAttName.getBuffer();
     1392    const XMLCh * fullName = attDef.getFullName();
     1393    if (fDoNamespaces)
     1394    {
     1395        int colonInd = -1;
     1396        const XMLCh * uri = getURIForQName(fullName, colonInd);
     1397        if (uri)
     1398        {
     1399            bAttName.set(chOpenCurly);
     1400            bAttName.append(uri);
     1401            bAttName.append(chCloseCurly);
     1402            bAttName.append(&fullName[colonInd + 1]);
     1403            fullName = bAttName.getRawBuffer();
     1404        }
     1405    }
     1406    fDTDValidator->emitError(XMLValid::RequiredAttrNotProvided, fullName);
     1407}
     1408
     1409void IGXMLScanner::reportAttributeNotDefinedForElement(const DTDElementDecl & elemDecl, const XMLCh * attributeName)
     1410{
     1411    XMLBufBid bbAttName(&fBufMgr);
     1412    XMLBuffer & bAttName = bbAttName.getBuffer();
     1413    if (fDoNamespaces)
     1414    {
     1415        int colonInd = -1;
     1416        const XMLCh * uri = getURIForQName(attributeName, colonInd);
     1417        if (uri)
     1418        {
     1419            bAttName.set(chOpenCurly);
     1420            bAttName.append(uri);
     1421            bAttName.append(chCloseCurly);
     1422            bAttName.append(&attributeName[colonInd + 1]);
     1423            attributeName = bAttName.getRawBuffer();
     1424        }
     1425    }
     1426    fDTDValidator->emitError(XMLValid::AttNotDefinedForElement, attributeName, elemDecl.getFullName());
     1427}
     1428
     1429void IGXMLScanner::reportRequiredAttribute(const SchemaAttDef & attDef)
     1430{
     1431    XMLBufBid bbAttName(&fBufMgr);
     1432    XMLBuffer & bAttName = bbAttName.getBuffer();
     1433    const XMLCh * fullName = attDef.getFullName();
     1434    if (fDoNamespaces)
     1435    {
     1436        int colonInd = -1;
     1437        const XMLCh * uri = getURIForQName(fullName, colonInd);
     1438        if (uri)
     1439        {
     1440            bAttName.set(chOpenCurly);
     1441            bAttName.append(uri);
     1442            bAttName.append(chCloseCurly);
     1443            bAttName.append(&fullName[colonInd + 1]);
     1444            fullName = bAttName.getRawBuffer();
     1445        }
     1446    }
     1447    fSchemaValidator->emitError(XMLValid::RequiredAttrNotProvided, fullName);
     1448}
     1449
    13971450XERCES_CPP_NAMESPACE_END
  • icXML/icXML-devel/src/icxercesc/internal/IGXMLScanner.hpp

    r3104 r3150  
    235235        , XMLBuffer &                   toFill
    236236        , bool      &                   isPredefined       
    237         , XMLReader::XMLVersion &       version
     237        , bool      &                   isExternal
    238238        , XMLFileLoc &                  line
    239239        , XMLFileLoc &                  column
     
    331331    IDISA_ALWAYS_INLINE
    332332    DatatypeValidator * getAnySimpleTypeValidator();
     333
     334    // -----------------------------------------------------------------------
     335    //  Private error reporting methods
     336    // -----------------------------------------------------------------------
     337
     338    void reportRequiredAttribute(const DTDAttDef & attDef);
     339
     340    void reportRequiredAttribute(const SchemaAttDef & attDef);
     341
     342    void reportAttributeNotDefinedForElement(const DTDElementDecl & elemDecl, const XMLCh * attributeName);
    333343
    334344        // -----------------------------------------------------------------------
     
    465475    XMLGrammarResolver                      fGrammarList;
    466476    DatatypeValidator *                     fAnySimpleTypeValidator;
    467         XMLParserImpl<IGXMLScanner>*            fProgressiveParser;
    468477};
    469478
     
    674683                // used with or without namespaces, but schemas cannot be used without
    675684                // namespaces.
    676                 elemDecl = new (fMemoryManager) DTDElementDecl(element.fQName, DTDElementDecl::Any, fMemoryManager);
     685                elemDecl = new (fMemoryManager) DTDElementDecl(element.getQName(), DTDElementDecl::Any, fMemoryManager);
    677686                elemDecl->setId(fDTDElemNonDeclPool->put((DTDElementDecl*)elemDecl));
    678687                elemDecl->setCreateReason(XMLElementDecl::JustFaultIn);
     
    898907        if (fGrammarType == Grammar::SchemaGrammarType)
    899908        {
     909            DEBUG_MESSAGE("fSchemaValidator->validateElement(elemDecl);")
     910
    900911            ComplexTypeInfo * typeInfo;
    901912            if (fValidate)
     
    983994XMLElementDecl * IGXMLScanner::findElementDecl(XMLSymbol & element, unsigned int uriId, unsigned int scope, Grammar * grammar)
    984995{   
     996    DEBUG_MESSAGE(" -- findElementDecl(" << element << ',' << uriId << ',' << scope << ',' << grammar << ')')
    985997    size_t index;
    986998    XMLElementDecl * elemDecl = element.getElemDecl(uriId, scope, index);
     
    10401052            if (fValidate)
    10411053            {
    1042                 fDTDValidator->emitError(XMLValid::AttNotDefinedForElement, attribute.getName(), dtdElemDecl.getFullName());
     1054                reportAttributeNotDefinedForElement(dtdElemDecl, attribute.getName());
    10431055            }
    10441056        }
     
    13391351                        if (defType == XMLAttDef::Required)
    13401352                        {
    1341                             fDTDValidator->emitError(XMLValid::RequiredAttrNotProvided, attDef.getFullName());
     1353                            reportRequiredAttribute(attDef);
    13421354                        }
    13431355                    }
     
    13891401                        if ((defType == XMLAttDef::Required) || (defType == XMLAttDef::Required_And_Fixed))
    13901402                        {
    1391                             fSchemaValidator->emitError(XMLValid::RequiredAttrNotProvided, attDef.getFullName());
     1403                            reportRequiredAttribute(attDef);
    13921404                            fPSVIElemContext.fErrorOccurred = true;
    13931405                        }
  • icXML/icXML-devel/src/icxercesc/internal/MemoryManagerImpl.cpp

    r3103 r3150  
    4444        {
    4545        p = ::operator new(size);
    46         if (likely(p != 0))
     46        if (likely(p != NULL))
    4747        {
    48             #ifdef PRINT_DEBUG_MESSAGE
    49             // eliminate erroneous valgrind issue.
    50             Array<uint8_t>::memzero((uint8_t*)p, size);
    51             #endif
    5248            return p;
    5349        }
     
    5551        catch (...)
    5652        {
     53
    5754        }
    58         throw OutOfMemoryException();
     55    throw OutOfMemoryException();
    5956}
    6057
    6158void MemoryManagerImpl::deallocate(void* p)
    6259{
    63     if (likely(p != 0)) ::operator delete(p);
     60    ::operator delete(p);
    6461}
    6562
  • icXML/icXML-devel/src/icxercesc/internal/ReaderMgr.cpp

    r3104 r3150  
    851851bool ReaderMgr::isScanningPERefOutOfLiteral() const
    852852{
    853         // If the current reader is not for an entity, then definitely not
    854         if (!fCurEntity)
    855                 return false;
    856 
    857853        //
    858854        //  If this is a PE entity, and its not being expanded in a literal
    859855        //  then its true.
    860856        //
    861         if ((fCurReader->getType() == XMLReader::Type_PE)
    862         &&  (fCurReader->getRefFrom() == XMLReader::RefFrom_NonLiteral))
     857    if (fCurEntity && (fCurReader->getType() == XMLReader::Type_PE) && (fCurReader->getRefFrom() == XMLReader::RefFrom_NonLiteral))
    863858        {
    864859                return true;
  • icXML/icXML-devel/src/icxercesc/internal/ReaderMgr.hpp

    r3103 r3150  
    7575        ReaderMgr(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
    7676        ~ReaderMgr();
    77 
    7877
    7978        // -----------------------------------------------------------------------
     
    110109        XMLCh skipUntilInOrWS(const XMLCh* const listToSkip);
    111110        bool peekString(const XMLCh* const toPeek);
    112 
    113111
    114112        // -----------------------------------------------------------------------
     
    324322
    325323inline bool ReaderMgr::getName(XMLBuffer& toFill)
    326 {
     324{   
    327325        toFill.reset();
    328         return fCurReader->getName(toFill, false);
     326    return fCurReader->getName(toFill, false);
    329327}
    330328
  • icXML/icXML-devel/src/icxercesc/internal/WFXMLScanner.cpp

    r3104 r3150  
    4747: XMLScanner(valToAdopt, grammarResolver, manager)
    4848, fElementList(32, manager, true)
    49 , fProgressiveParser(0)
    5049{
    5150        CleanupType cleanup(this, &WFXMLScanner::cleanUp);
     
    7978: XMLScanner(docHandler, docTypeHandler, entityHandler, errHandler, valToAdopt, grammarResolver, manager)
    8079, fElementList(32, manager, true)
    81 , fProgressiveParser(0)
    8280{
    8381        CleanupType cleanup(this, &WFXMLScanner::cleanUp);
     
    222220void WFXMLScanner::scanFirst()
    223221{
    224         fProgressiveParser = fReaderMgr.getCurrentReader()->scanFirst<WFXMLScanner>(this);
     222    fReaderMgr.getCurrentReader()->scanFirst<WFXMLScanner>(this);
    225223}
    226224
     
    233231        try
    234232        {
    235                 const bool gotData =
    236                         fReaderMgr.getCurrentReader()->scanNext<WFXMLScanner>(*fProgressiveParser);
    237 
    238                 if (!gotData)
    239                 {
    240                         if (fDocHandler)
    241                                 fDocHandler->endDocument();
    242                 }
    243 
    244                 return gotData;
     233        if (likely(fReaderMgr.getCurrentReader()->scanNext<WFXMLScanner>()))
     234                {
     235            return true;
     236                }
     237
     238        if (fDocHandler)
     239            fDocHandler->endDocument();
    245240        }
    246241        catch(const XMLErrs::Codes)
     
    309304void WFXMLScanner::cleanUp()
    310305{
    311         delete fProgressiveParser;
     306
    312307}
    313308
  • icXML/icXML-devel/src/icxercesc/internal/WFXMLScanner.hpp

    r3103 r3150  
    275275
    276276    ValueVectorOf<DTDElementDecl*>      fElementList;
    277 
    278         XMLParserImpl<WFXMLScanner>*        fProgressiveParser;
    279277};
    280278
  • icXML/icXML-devel/src/icxercesc/internal/XMLReader.cpp

    r3103 r3150  
    3838#include <icxmlc/XMLDefaultCharacterSetAdapter.hpp>
    3939#include <icxmlc/XMLNameChars.hpp>
     40#include <icxmlc/XMLWhitespaceNormalizer.hpp>
    4041
    4142XERCES_CPP_NAMESPACE_BEGIN
     
    7273        , fEncodingStr(0)
    7374        , fForcedEncoding(false)
    74         , fNoMore(false)
     75    , fNoMore(false)
     76    , fEOF(false)
    7577        , fPublicId(XMLString::replicate(pubId, manager))
    7678        , fRawBufIndex(0)
     
    7981        , fReaderNum(0xFFFFFFFF)
    8082        , fRefFrom(from)
    81         , fSentTrailingSpace(false)
    8283        , fSource(source)
    8384        , fSrcOfsBase(0)
     
    8990        , fCharacterSetAdapter(0)
    9091        , fType(type)
     92    , fParser(0)
    9193        , fMemoryManager(manager)
    9294{
     
    146148        , fForcedEncoding(true)
    147149        , fNoMore(false)
     150    , fEOF(false)
    148151        , fPublicId(XMLString::replicate(pubId, manager))
    149152        , fRawBufIndex(0)
     
    152155        , fReaderNum(0xFFFFFFFF)
    153156        , fRefFrom(from)
    154         , fSentTrailingSpace(false)
    155157        , fSource(source)
    156158        , fSrcOfsBase(0)
     
    162164        , fCharacterSetAdapter(0)
    163165        , fType(type)
     166    , fParser(0)
    164167        , fMemoryManager(manager)
    165168{
     
    297300        , fForcedEncoding(true)
    298301        , fNoMore(false)
     302    , fEOF(false)
    299303        , fPublicId(XMLString::replicate(pubId, manager))
    300304        , fRawBufIndex(0)
     
    303307        , fReaderNum(0xFFFFFFFF)
    304308        , fRefFrom(from)
    305         , fSentTrailingSpace(false)
    306309        , fSource(source)
    307310        , fSrcOfsBase(0)
     
    313316        , fCharacterSetAdapter(0)
    314317        , fType(type)
     318    , fParser(0)
    315319        , fMemoryManager(manager)
    316320{
    317321    DEBUG_MESSAGE("XMLReader(...) 3")
    318 
    319322
    320323        setXMLVersion(version);
     
    381384        delete fTranscoder;
    382385        delete fCharacterSetAdapter;
     386    if (unlikely(fEncoding == XMLRecognizer::OtherEncoding))
     387    {
     388        fMemoryManager->deallocate(const_cast<XMLCh*>(fEncodingStr));
     389    }
    383390}
    384391
     
    406413                return true;
    407414
     415    if (unlikely(fEncoding == XMLRecognizer::OtherEncoding))
     416    {
     417        fMemoryManager->deallocate(const_cast<XMLCh*>(fEncodingStr));
     418    }
     419
    408420        //
    409421        // upperCase the newEncoding first for better performance
    410422        //
    411         XMLCh * inputEncoding = XMLString::replicate(newEncoding, fMemoryManager);
    412         XMLString::upperCaseASCII(inputEncoding);
     423    XMLCh * inputEncoding = XMLString::replicate(newEncoding, fMemoryManager);
     424    XMLString::upperCaseASCII(inputEncoding);
    413425        XMLRecognizer::Encodings newBaseEncoding;
    414426
     
    473485                //  new one.
    474486                //
    475                 fEncoding = XMLRecognizer::encodingForName(inputEncoding);
    476 
     487        fEncoding = XMLRecognizer::encodingForName(inputEncoding);
    477488                //
    478489                //  If it does not come back as one of the auto-sensed encodings, then we
     
    481492                if (fEncoding == XMLRecognizer::OtherEncoding)
    482493                {
    483                         //fMemoryManager->deallocate(fEncodingStr);
    484                         fEncodingStr = inputEncoding;
     494            fEncodingStr = inputEncoding;
    485495                        // Replace the default UTF-8 transcoder that was
    486496                        // installed based on the initial basicEncodingProbe.
     
    493503                                , fMemoryManager
    494504                        );
    495 
    496                 }
    497                 else
    498                 {
    499                         // Store the new encoding string since it is just an intrinsic
    500                         //fMemoryManager->deallocate(fEncodingStr);
    501                         fEncodingStr = inputEncoding;
    502 
    503                 }
     505                }
     506        else
     507        {
     508            fMemoryManager->deallocate(inputEncoding);
     509            fEncodingStr = XMLRecognizer::nameForEncoding(fEncoding, fMemoryManager);
     510        }
    504511        }
    505512
     
    801808//            fRawBufIndex = (utf16Ptr - utf16src) * sizeof(XMLCh);
    802809
    803             DEBUG_MESSAGE("fRawBufIndex=" << fRawBufIndex << "," << fRawBytesAvail << "," << fSwapped)
    804 
    805810                        break;
    806811                }
     
    871876    #endif
    872877
     878    //
     879    //  If there are any bytes left, move them down to the start. There
     880    //  should only ever be (max bytes per char - 1) at the most.
     881    //
    873882    Array<XMLByte>::move(&fRawByteBuf[from], &fRawByteBuf[to], (fRawBytesRead - from));
    874883
     
    889898    {
    890899        fRawBytesAvail = fRawBytesRead;
     900        fEOF = true;
    891901        #ifdef PRINT_DEBUG_MESSAGE
    892902        // clear out the "used" data from the buffer if and only if we're going to print it out
     
    904914void XMLReader::refreshRawBuffer()
    905915{
    906         //
    907         //  If there are any bytes left, move them down to the start. There
    908         //  should only ever be (max bytes per char - 1) at the most.
    909         //
    910         const XMLSize_t bytesLeft = fRawBytesRead - fRawBufIndex;
    911         fSrcOfsBase = 0;
    912         // Move the existing ones down
     916    DEBUG_MESSAGE("XMLReader::refreshRawBuffer()")
     917
     918    //
     919    //  If there are any bytes left, move them down to the start. There
     920    //  should only ever be (max bytes per char - 1) at the most.
     921    //
     922    const XMLSize_t bytesLeft = fRawBytesRead - fRawBufIndex;
     923    // Move the existing ones down
    913924    Array<XMLByte>::move(&fRawByteBuf[fRawBufIndex], &fRawByteBuf[0], bytesLeft);
    914         fRawBytesRead = fStream->readBytes(&fRawByteBuf[bytesLeft], (kRawBufSize  + sizeof(BytePack)) - bytesLeft) + bytesLeft;
    915         fRawBytesAvail = likely(fRawBytesRead >= kRawBufSize) ? kRawBufSize : fRawBytesRead;
    916         fRawBufIndex = 0;
     925    fRawBytesRead = fStream->readBytes(&fRawByteBuf[bytesLeft], (kRawBufSize + sizeof(BytePack)) - bytesLeft) + bytesLeft;
     926    if (likely(fRawBytesRead >= kRawBufSize))
     927    {
     928        fRawBytesAvail = kRawBufSize;
     929    }
     930    else
     931    {
     932        fRawBytesAvail = fRawBytesRead;
     933        fEOF = true;
     934    }
     935    fRawBufIndex = 0;
     936}
     937
     938bool XMLReader::refreshCharBuffer()
     939{
     940    DEBUG_MESSAGE("XMLReader::refreshCharBuffer()")
     941
     942    // If the no more flag is set, then don't bother doing anything.
     943    if (unlikely(fNoMore))
     944    {
     945        return false;
     946    }
     947
     948    //
     949        //  If no transcoder has been created yet, then we never saw the
     950        //  any encoding="" string and the encoding was not forced, so lets
     951        //  create one now. We know that it won't change now.
     952        //
     953        //  However, note that if we autosensed EBCDIC, then we have to
     954        //  consider it an error if we never got an encoding since we don't
     955        //  know what variant of EBCDIC it is.
     956        //
     957    if (unlikely(!fTranscoder))
     958        {
     959                constructTranscoder();
     960        }
     961
     962    //
     963    //  If there are spare chars, then adjust the raw buffer index
     964    //
     965    fRawBufIndex = calculateRawBufIndex();
     966
     967    //
     968        //  And then get more chars, starting after any spare chars that were
     969        //  left over from the last time.
     970        //
     971    fCharsAvail = xcodeMoreChars(&fCharBuf[0], &fCharSizeBuf[0], kCharBufSize);
     972
     973    fNoMore = (fCharsAvail == 0);
     974
     975    // Reset the buffer index to zero, so we start from the 0th char again
     976    fCharIndex = 0;
     977
     978    //
     979    //  If no chars available, then we have to check for one last thing. If
     980    //  this is reader for a PE and its not being expanded inside a literal,
     981    //  then unget a trailing space.
     982    //
     983    if (unlikely(fNoMore && (fType == Type_PE) && (fRefFrom == RefFrom_NonLiteral)))
     984    {
     985        DEBUG_MESSAGE(" -- appending trailing PE space to buffer")
     986        fCharBuf[0] = chSpace;
     987        fCharsAvail = 1;
     988        return true;
     989    }
     990
     991    return !fNoMore;
    917992}
    918993
     
    924999XMLSize_t
    9251000XMLReader::xcodeMoreChars(       XMLCh* const            bufToFill
    926                                                 ,       unsigned char* const    charSizes
    927                                                 , const XMLSize_t               maxChars)
    928 {
    929         XMLSize_t charsDone = 0;
    930         XMLSize_t bytesEaten = 0;
    931         bool needMode = false;
     1001                        ,       unsigned char* const    charSizes
     1002                        , const XMLSize_t               maxChars)
     1003{
     1004    XMLSize_t charsDone = 0;
     1005    XMLSize_t bytesEaten = 0;
     1006    bool needMore = false;
    9321007
    9331008    do
    934         {
    935                 // If our raw buffer is low, then lets load up another batch of
    936                 // raw bytes now.
    937                 //
    938                 XMLSize_t bytesLeft = fRawBytesAvail - fRawBufIndex;
    939 
    940                 if (needMode || bytesLeft == 0 || bytesLeft < kCharBufSize)
    941                 {
    942                         refreshRawBuffer();
    943 
    944                         // If there are no characters or if we need more but didn't get
    945                         // any, return zero now.
    946                         //
    947                         if (fRawBytesAvail == 0 || (needMode && (bytesLeft == fRawBytesAvail - fRawBufIndex)))
    948                         {
    949                                 return 0;
    950                         }
    951                 }
    952 
    953                 fSrcOfsBase = fRawBufIndex;
    954 
    955 
    956                 // Ask the transcoder to internalize another batch of chars. It is
    957                 // possible that there is data in the raw buffer but the transcoder
    958                 // is unable to produce anything because transcoding of multi-byte
    959                 // encodings may have left a few bytes representing a partial
    960                 // character in the buffer that can't be used until the next chunk
    961                 // (and the rest of the character) is read. In this case set the
    962                 // needMore flag and try again.
    963                 //
    964 
    965                 charsDone = fTranscoder->transcodeFrom
    966                 (
    967                   &fRawByteBuf[fRawBufIndex]
    968                   , fRawBytesAvail - fRawBufIndex
    969                   , bufToFill
    970                   , maxChars
    971                   , bytesEaten
    972                   , charSizes
    973                 );
    974 
    975                 needMode = (bytesEaten == 0);
    976                 fRawBufIndex += bytesEaten;
    977         }
    978     while (unlikely(needMode));
    979 
    980         return charsDone;
    981 }
    982 
    983 /***
    984  *
    985  * XML1.1
    986  *
    987  * 2.11 End-of-Line Handling
    988  *
    989  *    XML parsed entities are often stored in computer files which, for editing
    990  *    convenience, are organized into lines. These lines are typically separated
    991  *    by some combination of the characters CARRIAGE RETURN (#xD) and LINE FEED (#xA).
    992  *
    993  *    To simplify the tasks of applications, the XML processor MUST behave as if
    994  *    it normalized all line breaks in external parsed entities (including the document
    995  *    entity) on input, before parsing, by translating all of the following to a single
    996  *    #xA character:
    997  *
    998  *  1. the two-character sequence #xD #xA
    999  *  2. the two-character sequence #xD #x85
    1000  *  3. the single character #x85
    1001  *  4. the single character #x2028
    1002  *  5. any #xD character that is not immediately followed by #xA or #x85.
    1003  *
    1004  *
    1005  ***/
    1006 void XMLReader::handleEOL(XMLCh& curCh, bool inDecl)
    1007 {
    1008 #ifndef EXCLUDE_TRADITIONAL_XERCES_FUNCTIONS_AND_VARIABLES
    1009         // 1. the two-character sequence #xD #xA
    1010         // 2. the two-character sequence #xD #x85
    1011         // 5. any #xD character that is not immediately followed by #xA or #x85.
    1012         switch(curCh)
    1013         {
    1014         case chCR:
    1015                 fCurCol = 1;
    1016                 fCurLine++;
    1017 
    1018                 //
    1019                 //  If not already internalized, then convert it to an
    1020                 //  LF and eat any following LF.
    1021                 //
    1022                 if (fSource == Source_External)
    1023                 {
    1024                         if ((fCharIndex < fCharsAvail) || refreshCharBuffer())
    1025                         {
    1026                                 if ( fCharBuf[fCharIndex] == chLF              ||
    1027                                         ((fCharBuf[fCharIndex] == chNEL) && fNEL)  )
    1028                                 {
    1029                                         fCharIndex++;
    1030                                 }
    1031                         }
    1032                         curCh = chLF;
    1033                 }
    1034                 break;
    1035 
    1036         case chLF:
    1037                 fCurCol = 1;
    1038                 fCurLine++;
    1039                 break;
    1040 
    1041         // 3. the single character #x85
    1042         // 4. the single character #x2028
    1043         case chNEL:
    1044         case chLineSeparator:
    1045                 if (inDecl && fXMLVersion == XMLV1_1)
    1046                 {
    1047 
    1048                 /***
    1049                  * XML1.1
    1050                  *
    1051                  * 2.11 End-of-Line Handling
    1052                  *  ...
    1053                  *   The characters #x85 and #x2028 cannot be reliably recognized and translated
    1054                  *   until an entity's encoding declaration (if present) has been read.
    1055                  *   Therefore, it is a fatal error to use them within the XML declaration or
    1056                  *   text declaration.
    1057                  *
    1058                  ***/
    1059                         ThrowXMLwithMemMgr1
    1060                                 (
    1061                                 TranscodingException
    1062                                 , XMLExcepts::Reader_NelLsepinDecl
    1063                                 , fSystemId
    1064                                 , fMemoryManager
    1065                                 );
    1066                 }
    1067 
    1068                 if (fNEL && fSource == Source_External)
    1069                 {
    1070                         fCurCol = 1;
    1071                         fCurLine++;
    1072                         curCh = chLF;
    1073                 }
    1074                 break;
    1075         default:
    1076                 fCurCol++;
    1077         }
    1078 #endif
    1079 }
    1080 
    1081 IDISA_ALWAYS_INLINE
    1082 static XMLSize_t sumCharSize
    1083 (
    1084         const unsigned char *   fCharSizeBuf
    1085         , const XMLSize_t               startIndex
    1086         , const XMLSize_t               endIndex
    1087 )
    1088 {
    1089         XMLSize_t offset = fCharSizeBuf[startIndex];
    1090         for (XMLSize_t i = startIndex + 1; i < endIndex; i++)
    1091         {
    1092                 offset += fCharSizeBuf[i];
    1093         }
    1094 
    1095         return offset;
    1096 }
    1097 
    1098 bool XMLReader::refreshCharBuffer()
    1099 {
    1100 #ifndef EXCLUDE_TRADITIONAL_XERCES_FUNCTIONS_AND_VARIABLES
    1101         // If the no more flag is set, then don't bother doing anything.
    1102         if (fNoMore)
    1103                 return false;
    1104 
    1105         // See if we have any existing chars.
    1106         const XMLSize_t spareChars = fCharsAvail - fCharIndex;
    1107 
    1108         // If we are full, then don't do anything.
    1109         if (spareChars == kCharBufSize)
    1110                 return true;
    1111 
    1112         //
    1113         //  If no transcoder has been created yet, then we never saw the
    1114         //  any encoding="" string and the encoding was not forced, so lets
    1115         //  create one now. We know that it won't change now.
    1116         //
    1117         //  However, note that if we autosensed EBCDIC, then we have to
    1118         //  consider it an error if we never got an encoding since we don't
    1119         //  know what variant of EBCDIC it is.
    1120         //
    1121         if (!fTranscoder)
    1122         {
    1123                 constructTranscoder();
    1124         }
    1125 
    1126         //
    1127         //  If there are spare chars, then move then down to the bottom. We
    1128         //  have to move the char sizes down also.
    1129         //
    1130         if (spareChars)
    1131         {
    1132                 fRawBufIndex -= sumCharSize(fCharSizeBuf, fCharIndex, fCharsAvail);
    1133         }
    1134 
    1135         //
    1136         //  And then get more chars, starting after any spare chars that were
    1137         //  left over from the last time.
    1138         //
    1139         fCharsAvail = xcodeMoreChars
    1140         (
    1141                 &fCharBuf[0]
    1142                 , &fCharSizeBuf[0]
    1143                 , kCharBufSize
    1144         );
    1145 
    1146         // Reset the buffer index to zero, so we start from the 0th char again
    1147         fCharIndex = 0;
    1148 
    1149         //
    1150         //  If no chars available, then we have to check for one last thing. If
    1151         //  this is reader for a PE and its not being expanded inside a literal,
    1152         //  then unget a trailing space. We use a boolean to avoid triggering
    1153         //  this more than once.
    1154         //
    1155         if (!fCharsAvail
    1156         &&  (fType == Type_PE)
    1157         &&  (fRefFrom == RefFrom_NonLiteral)
    1158         &&  !fSentTrailingSpace)
    1159         {
    1160                 fCharBuf[0] = chSpace;
    1161                 fCharsAvail = 1;
    1162                 fSentTrailingSpace = true;
    1163         }
    1164 
    1165         //
    1166         //  If we get here with no more chars, then set the fNoMore flag which
    1167         //  lets us optimize and know without checking that no more chars are
    1168         //  available.
    1169         //
    1170         if (!fCharsAvail)
    1171                 fNoMore = true;
    1172 
    1173         return (fCharsAvail != 0);
    1174 #else
    1175         return 0;
    1176 #endif
    1177 }
    1178 
    1179 
     1009    {
     1010        // If our raw buffer is low, then lets load up another batch of
     1011        // raw bytes now.
     1012        //
     1013        XMLSize_t bytesLeft = fRawBytesAvail - fRawBufIndex;
     1014
     1015        DEBUG_MESSAGE("bytesLeft=" << bytesLeft)
     1016
     1017        if (unlikely(needMore || bytesLeft < kCharBufSize))
     1018        {
     1019            // If there are no characters or if we need more but didn't get any, return zero.
     1020            if (unlikely(needMore && fEOF))
     1021            {
     1022                return 0;
     1023            }
     1024            refreshRawBuffer();
     1025        }
     1026
     1027        fSrcOfsBase = fRawBufIndex;
     1028
     1029
     1030        // Ask the transcoder to internalize another batch of chars. It is
     1031        // possible that there is data in the raw buffer but the transcoder
     1032        // is unable to produce anything because transcoding of multi-byte
     1033        // encodings may have left a few bytes representing a partial
     1034        // character in the buffer that can't be used until the next chunk
     1035        // (and the rest of the character) is read. In this case set the
     1036        // needMore flag and try again.
     1037        //
     1038
     1039        charsDone = fTranscoder->transcodeFrom
     1040        (
     1041            &fRawByteBuf[fRawBufIndex]
     1042            , fRawBytesAvail - fRawBufIndex
     1043            , bufToFill
     1044            , maxChars
     1045            , bytesEaten
     1046            , charSizes
     1047        );
     1048
     1049        normalizeEOL(bufToFill, charSizes, charsDone, bytesEaten);
     1050
     1051        needMore = (bytesEaten == 0);
     1052        fRawBufIndex += bytesEaten;
     1053    }
     1054    while (unlikely(needMore));
     1055
     1056    return charsDone;
     1057}
    11801058
    11811059// ---------------------------------------------------------------------------
    11821060//  XMLReader: Scanning methods
    11831061// ---------------------------------------------------------------------------
    1184 bool XMLReader::getName(XMLBuffer& toFill, const bool token)
     1062bool XMLReader::getName(XMLBuffer & toFill, const bool token)
    11851063{
    11861064    //  Ok, first lets see if we have chars in the buffer. If not, then lets
     
    11921070
    11931071    XMLSize_t charIndex = fCharIndex;
    1194 
    11951072    // Check the name start char
    11961073    if (!token)
    11971074    {
    1198         if (!XMLNameChar::testNameStart(fCharBuf, charIndex))
     1075        if (unlikely(charIndex >= fCharsAvail))
     1076        {
     1077            if (unlikely(!refreshCharBuffer()))
     1078            {
     1079                return false;
     1080            }
     1081            charIndex = fCharIndex;
     1082        }
     1083
     1084        if (unlikely(!XMLNameChar::testNameStart(fCharBuf, charIndex)))
    11991085        {
    12001086            return false;
     
    12081094        while (charIndex < fCharsAvail)
    12091095        {
    1210             if (!XMLNameChar::testNameChar(fCharBuf, charIndex))
     1096            if (unlikely(!XMLNameChar::testNameChar(fCharBuf, charIndex)))
    12111097            {
    12121098                done = true;
     
    12151101        }
    12161102
    1217                 // we have to copy the accepted character(s), and update column
     1103        // we have to copy the accepted character(s), and update column
    12181104        fCurCol += (XMLFileLoc)(charIndex - fCharIndex);
    12191105        toFill.append(&fCharBuf[fCharIndex], charIndex - fCharIndex);
     
    12271113        // we ran out of transcoded characters; attempt to refresh the buffer.
    12281114        // if we've hit the end of the input, then this is an error.
    1229         if (!refreshCharBuffer())
     1115        if (unlikely(!refreshCharBuffer()))
    12301116        {
    1231             return false;
     1117            break;
    12321118        }
    12331119        charIndex = fCharIndex;
     
    12811167        if (!refreshCharBuffer())
    12821168        {
    1283             return false;
     1169            break;
    12841170        }
    12851171        charIndex = fCharIndex;
     
    12991185                return false;
    13001186        }
    1301         if (fCharIndex == fCharsAvail && !refreshCharBuffer())
     1187    if (fCharIndex == fCharsAvail && !refreshCharBuffer())
    13021188        {
    13031189                *colonPosition = -1;
     
    13391225                        //  we've hit a non-space and need to return.
    13401226                        //
    1341                         if (isWhitespace(curCh))
     1227            if (XMLNameChar::isWhitespace(curCh, true))
    13421228                        {
    13431229                                // Eat this char
    13441230                                fCharIndex++;
    1345 
    1346                                 //
    1347                                 //  'curCh' is a whitespace(x20|x9|xD|xA), so we only can have
    1348                                 //  end-of-line combinations with a leading chCR(xD) or chLF(xA)
    1349                                 //
    1350                                 //  100000 x20
    1351                                 //  001001 x9
    1352                                 //  001010 chLF
    1353                                 //  001101 chCR
    1354                                 //  -----------
    1355                                 //  000110 == (chCR|chLF) & ~(0x9|0x20)
    1356                                 //
    1357                                 //  if the result of thelogical-& operation is
    1358                                 //  true  : 'curCh' must be xA  or xD
    1359                                 //  false : 'curCh' must be x20 or x9
    1360                                 //
    1361                                 if ( ( curCh & (chCR|chLF) & ~(0x9|0x20) ) == 0 )
    1362                                 {
    1363                                         fCurCol++;
    1364                                 }
    1365                                 else
    1366                                 {
    1367                                         handleEOL(curCh, false);
    1368                                 }
    1369 
     1231                handleEOL(curCh, false);
    13701232                                // Ok we can add this guy to our buffer
    13711233                                toFill.append(curCh);
     
    14041266                        //  it. Else, we need to return.
    14051267                        //
    1406                         if (!isWhitespace(curCh) && (curCh != toCheck))
     1268            if (!XMLNameChar::isWhitespace(curCh, false) && (curCh != toCheck))
    14071269                        {
    14081270                                // Eat this char
    14091271                                fCharIndex++;
    1410 
    1411                                 //
    1412                                 //  'curCh' is not a whitespace(x20|x9|xD|xA), so we only can
    1413                                 //  have end-of-line combinations with a leading chNEL(x85) or
    1414                                 //  chLineSeparator(x2028)
    1415                                 //
    1416                                 //  0010000000101000 chLineSeparator
    1417                                 //  0000000010000101 chNEL
    1418                                 //  ---------------------
    1419                                 //  1101111101010010 == ~(chNEL|chLineSeparator)
    1420                                 //
    1421                                 //  if the result of the logical-& operation is
    1422                                 //  true  : 'curCh' can not be chNEL or chLineSeparator
    1423                                 //  false : 'curCh' can be chNEL or chLineSeparator
    1424                                 //
    1425                                 if ( curCh & (XMLCh) ~(chNEL|chLineSeparator) )
    1426                                 {
    1427                                         fCurCol++;
    1428                                 } else
    1429                                 {
    1430                                         handleEOL(curCh, false);
    1431                                 }
    1432 
     1272                handleEOL(curCh, false);
    14331273                                // Add it to our buffer
    14341274                                toFill.append(curCh);
     
    14551295bool XMLReader::skipIfQuote(XMLCh& chGotten)
    14561296{
    1457         if (fCharIndex == fCharsAvail && !refreshCharBuffer())
     1297    if (fCharIndex == fCharsAvail && !refreshCharBuffer())
    14581298                return false;
    14591299
     
    14831323                        //  See if its a white space char. If so, then process it. Else
    14841324                        //  we've hit a non-space and need to return.
    1485                         if (isWhitespace(fCharBuf[fCharIndex]))
     1325            XMLCh Char = fCharBuf[fCharIndex];
     1326            if (XMLNameChar::isWhitespace(Char, false))
    14861327                        {
    14871328                                // Get the current char out of the buffer and eat it
    1488                                 XMLCh curCh = fCharBuf[fCharIndex++];
    14891329                                skippedSomething = true;
    1490                                 //
    1491                                 //  'curCh' is a whitespace(x20|x9|xD|xA), so we only can have
    1492                                 //  end-of-line combinations with a leading chCR(xD) or chLF(xA)
    1493                                 //
    1494                                 //  100000 x20
    1495                                 //  001001 x9
    1496                                 //  001010 chLF
    1497                                 //  001101 chCR
    1498                                 //  -----------
    1499                                 //  000110 == (chCR|chLF) & ~(0x9|0x20)
    1500                                 //
    1501                                 //  if the result of the logical-& operation is
    1502                                 //  true  : 'curCh' must be xA  or xD
    1503                                 //  false : 'curCh' must be x20 or x9
    1504                                 //
    1505                                 if ((curCh & (chCR|chLF) & ~(0x9|0x20)) == 0 )
    1506                                 {
    1507                                         fCurCol++;
    1508                                 }
    1509                                 else
    1510                                 {
    1511                                         handleEOL(curCh, inDecl);
    1512                                 }
     1330                handleEOL(Char, inDecl);
     1331                fCharIndex++;
    15131332                        }
    15141333                        else
     
    15201339                //  back to the top to keep getting spaces.
    15211340        }
    1522         while (refreshCharBuffer());
     1341    while (likely(refreshCharBuffer()));
    15231342
    15241343        // We never hit any non-space and ate up the whole reader
     
    15321351        //  nothing, then return false.
    15331352        //
    1534         if (fCharIndex == fCharsAvail)
     1353    if (unlikely(fCharIndex == fCharsAvail))
    15351354        {
    15361355                if (!refreshCharBuffer())
     
    15581377        //  nothing, then return false.
    15591378        //
    1560         if (fCharIndex == fCharsAvail)
     1379    if (fCharIndex == fCharsAvail)
    15611380        {
    15621381                if (!refreshCharBuffer())
     
    15681387        //  it and return true.
    15691388        //
    1570         const XMLCh curCh = fCharBuf[fCharIndex];
    1571         if (isWhitespace(curCh))
     1389    XMLCh curCh = fCharBuf[fCharIndex];
     1390    if (XMLNameChar::isWhitespace(curCh, false))
    15721391        {
    15731392                // Eat the character
    15741393                fCharIndex++;
    1575 
    1576                 //
    1577                 //  'curCh' is a whitespace(x20|x9|xD|xA), so we only can have
    1578                 //  end-of-line combinations with a leading chCR(xD) or chLF(xA)
    1579                 //
    1580                 //  100000 x20
    1581                 //  001001 x9
    1582                 //  001010 chLF
    1583                 //  001101 chCR
    1584                 //  -----------
    1585                 //  000110 == (chCR|chLF) & ~(0x9|0x20)
    1586                 //
    1587                 //  if the result of the logical-& operation is
    1588                 //  true  : 'curCh' must be xA  or xD
    1589                 //  false : 'curCh' must be x20 or x9
    1590                 //
    1591                 if ( ( curCh & (chCR|chLF) & ~(0x9|0x20) ) == 0 )
    1592                 {
    1593                         fCurCol++;
    1594                 } else
    1595                 {
    1596                         handleEOL((XMLCh&)curCh, false);
    1597                 }
    1598 
     1394        handleEOL(curCh, false);
    15991395                return true;
    16001396        }
     
    17171513        //
    17181514        XMLSize_t charsLeft = charsLeftInBuffer();
    1719         while (charsLeft < srcLen)
    1720         {
    1721                 refreshCharBuffer();
    1722                 XMLSize_t t = charsLeftInBuffer();
     1515    while (charsLeft < srcLen)
     1516        {
     1517        refreshCharBuffer();
     1518        XMLSize_t t = charsLeftInBuffer();
    17231519                 if (t == charsLeft)   // if the refreshCharBuf() did not add anything new
    17241520                         return false;     //   give up and return.
     
    17261522        }
    17271523
    1728 
    1729 
    1730 
    1731         //
     1524    //
    17321525        //  Ok, now we now that the current reader has enough chars in its
    17331526        //  buffer and that its index is back at zero. So we can do a quick and
     
    17391532
    17401533        return true;
     1534}
     1535
     1536const XMLCh * XMLReader::peekString(XMLSize_t length)
     1537{
     1538    XMLSize_t charsLeft = charsLeftInBuffer();
     1539    while (charsLeft < length)
     1540    {
     1541         refreshCharBuffer();
     1542         const XMLSize_t t = charsLeftInBuffer();
     1543         if (t == charsLeft)    // if the refreshCharBuf() did not add anything new
     1544             return NULL;       //   give up and return.
     1545         charsLeft = t;
     1546    }
     1547    return fCharBuf + fCharIndex;
    17411548}
    17421549
  • icXML/icXML-devel/src/icxercesc/internal/XMLReader.hpp

    r3103 r3150  
    3434#include <icxmlc/XMLConfig.hpp>
    3535#include <icxmlc/Array.hpp>
    36 
     36#include <icxmlc/XMLScanIterator.hpp>
     37#include <icxmlc/XMLStreamIterator.hpp>
    3738#include <iostream>
    3839
     
    219220        bool skippedString(const XMLCh* const toSkip);   
    220221        bool skippedStringLong(const XMLCh* toSkip);
     222    const XMLCh * peekString(XMLSize_t length);
    221223        bool peekString(const XMLCh* const toPeek);
    222224    bool peekString(const XMLCh* const toPeek, XMLSize_t length, bool mustBeFollowedByWhitespace = false);
     
    282284
    283285        template <class XMLScannerType>
    284         XMLParserImpl<XMLScannerType> * scanFirst(XMLScannerType * const scanner);
     286    void scanFirst(XMLScannerType * const scanner);
    285287
    286288        template <class XMLScannerType>
    287         bool scanNext(XMLParserImpl<XMLScannerType> & parser);
     289    bool scanNext();
    288290
    289291        void refreshRawBuffer(const XMLSize_t offset);
     
    331333        );
    332334
    333         void handleEOL
    334         (
    335                           XMLCh&   curCh
    336                         , bool     inDecl = false
    337         );
     335    void handleEOL(XMLCh & curCh, bool inDecl = false);
    338336
    339337        void refreshRawBuffer();
    340338
     339    XMLSize_t calculateRawBufIndex();
     340
    341341        void checkForSwapped();
     342
     343    void normalizeEOL(XMLCh* const bufToFill, unsigned char* const charSizes, XMLSize_t & charsDone, XMLSize_t & bytesEaten);
    342344
    343345        // -----------------------------------------------------------------------
     
    390392        //
    391393        //  fNoMore
    392         //      This is set when the source text is exhausted. It lets us know
    393         //      quickly that no more text is available.
     394    //      This is set when the transcoded text is exhausted and no more can
     395    //      be obtained from the fStream.
     396    //
     397    //  fEOF
     398    //      This is set when the source input is exhausted.
    394399        //
    395400        //  fRawBufIndex
     
    405410        //      helps deal with the last buffer's worth, which will usually not
    406411        //      be a full one.
    407         //
    408         //  fLowWaterMark
    409         //      The low water mark for the raw byte buffer.
    410         //
    411412        //
    412413        //  fReaderNum
     
    425426        //      These are the system and public ids of the source that this
    426427        //      reader is reading.
    427         //
    428         //  fSentTrailingSpace
    429         //      If we are a PE entity being read and we not referenced from a
    430         //      literal, then a leading and trailing space must be faked into the
    431         //      data. This lets us know we've done the trailing space already (so
    432         //      we don't just keep doing it again and again.)
    433428        //
    434429        //  fSource
     
    484479        //
    485480        //  fNEL
    486         //      Boolean indicates if NEL and LSEP should be recognized as NEL
     481    //      Boolean indicates if NELs and LSEPs should be recognized as EOLs
    487482        //
    488483        //  fXMLVersion
     
    491486
    492487        XMLSize_t                   fCharIndex;
    493         XMLCh                       fCharBuf[kCharBufSize];
     488    XMLCh                       fCharBuf[kCharBufSize + 1];
    494489        XMLSize_t                   fCharsAvail;
    495         unsigned char               fCharSizeBuf[kCharBufSize + sizeof(BytePack)];
     490    unsigned char               fCharSizeBuf[kCharBufSize + 1];
    496491        XMLFileLoc                  fCurCol;
    497492        XMLFileLoc                  fCurLine;
     
    500495        bool                        fForcedEncoding;
    501496        bool                        fNoMore;
     497    bool                        fEOF;
    502498        XMLCh*                      fPublicId;
    503499        XMLSize_t                   fRawBufIndex;
     
    507503        XMLSize_t                   fReaderNum;
    508504        RefFrom                     fRefFrom;
    509         bool                        fSentTrailingSpace;
    510505        Sources                     fSource;
    511506        XMLFilePos                  fSrcOfsBase;
     
    537532}
    538533
    539 inline bool XMLReader::isPlainContentChar(const XMLCh toCheck) const
    540 {
    541     DEPRECATED_FEATURE_IN_ICXML;
    542 }
    543 
    544 
    545534inline bool XMLReader::isFirstNameChar(const XMLCh toCheck) const
    546535{
     
    553542}
    554543
    555 inline bool XMLReader::isSpecialStartTagChar(const XMLCh toCheck) const
    556 {
    557     DEPRECATED_FEATURE_IN_ICXML;
    558 }
    559 
    560544inline bool XMLReader::isXMLChar(const XMLCh toCheck) const
    561545{
     
    570554inline bool XMLReader::isWhitespace(const XMLCh toCheck) const
    571555{
    572     return XMLNameChar::isWhitespace(toCheck, fXMLVersion == XMLReader::XMLV1_0 | fNEL);
     556    return XMLNameChar::isWhitespace(toCheck, !fNEL);
    573557}
    574558
     
    611595inline bool XMLReader::getNoMoreFlag() const
    612596{
    613         return fNoMore;
     597    return fNoMore;
    614598}
    615599
     
    665649{
    666650        fXMLVersion = version;
    667         if (version == XMLV1_1)
    668         {
    669                 fNEL = true;
    670         }
    671         else
    672         {
    673                 fNEL = XMLChar1_0::enableNEL;
    674         }
     651    const bool NEL = (version == XMLV1_1) ? true : XMLChar1_0::enableNEL;
     652    if (unlikely(NEL & !fNEL))
     653    {
     654        XMLSize_t avail = (fCharsAvail - fCharIndex);
     655        XMLSize_t bytesEaten;
     656        normalizeEOL(&fCharBuf[fCharIndex], &fCharSizeBuf[fCharIndex], avail, bytesEaten);
     657        fCharsAvail = fCharIndex + avail;
     658    }
     659    fNEL = NEL;
    675660}
    676661
     
    684669        //  reload logic.
    685670        //
    686         if (unlikely(fCharIndex >= fCharsAvail))
     671    if (unlikely(fCharIndex == fCharsAvail))
    687672        {
    688673                if (unlikely(!refreshCharBuffer()))
     
    691676
    692677        chGotten = fCharBuf[fCharIndex++];
    693 
    694         // Handle end of line normalization and line/col member maintenance.
    695         //
    696         // we can have end-of-line combinations with a leading
    697         // chCR(xD), chLF(xA), chNEL(x85), or chLineSeparator(x2028)
    698         //
    699         // 0000000000001101 chCR
    700         // 0000000000001010 chLF
    701         // 0000000010000101 chNEL
    702         // 0010000000101000 chLineSeparator
    703         // -----------------------
    704         // 1101111101010000 == ~(chCR|chLF|chNEL|chLineSeparator)
    705         //
    706         // if the result of the logical-& operation is
    707         // true  : 'curCh' can not be chCR, chLF, chNEL or chLineSeparator
    708         // false : 'curCh' can be chCR, chLF, chNEL or chLineSeparator
    709         //
    710         if ( chGotten & (XMLCh) ~(chCR|chLF|chNEL|chLineSeparator) )
    711         {
    712                 fCurCol++;
    713         }
    714         else
    715         {
    716                 handleEOL(chGotten, false);
    717         }
    718 
     678    handleEOL(chGotten, false);
    719679        return true;
    720680}
     
    734694        //  scenario.
    735695        //
    736         if (unlikely(fCharIndex >= fCharsAvail))
     696    if (unlikely(fCharIndex == fCharsAvail))
    737697        {
    738698                // Try to refresh the buffer
     
    758718}
    759719
     720/***
     721 *
     722 * XML1.1
     723 *
     724 * 2.11 End-of-Line Handling
     725 *
     726 *    XML parsed entities are often stored in computer files which, for editing
     727 *    convenience, are organized into lines. These lines are typically separated
     728 *    by some combination of the characters CARRIAGE RETURN (#xD) and LINE FEED (#xA).
     729 *
     730 *    To simplify the tasks of applications, the XML processor MUST behave as if
     731 *    it normalized all line breaks in external parsed entities (including the document
     732 *    entity) on input, before parsing, by translating all of the following to a single
     733 *    #xA character:
     734 *
     735 *  1. the two-character sequence #xD #xA
     736 *  2. the two-character sequence #xD #x85
     737 *  3. the single character #x85
     738 *  4. the single character #x2028
     739 *  5. any #xD character that is not immediately followed by #xA or #x85.
     740 *
     741 *
     742 ***/
     743
     744inline void XMLReader::normalizeEOL(XMLCh* const bufToFill, unsigned char* const charSizes, XMLSize_t & charsDone, XMLSize_t & bytesEaten)
     745{
     746    ubitblock deletedAnyCharacters = {0};
     747    // do end-of-line normalization on the transcoded input data
     748    XMLChIterator<chCR> crItr(bufToFill, charsDone);
     749
     750    size_t pos = 0;
     751
     752    if (likely(!fNEL))
     753    {
     754        // do XML 1.0 end of line normalization
     755        while (unlikely(crItr.next()))
     756        {
     757            pos = crItr.pos();
     758            bufToFill[pos++] = chLF;
     759            // did this buffer end with a CR?
     760            if (unlikely(pos == kCharBufSize))
     761            {
     762                // push back the CR just to be sure that we arent dealing with a CRLF
     763                bytesEaten -= charSizes[--charsDone];
     764                DEBUG_MESSAGE(" -- pushback(CR)")
     765                break;
     766            }
     767            if (unlikely(bufToFill[pos] == chLF))
     768            {
     769                // if we found a {CR,LF}, then mark the LF for deletion
     770                #ifdef __ARCH_64
     771                deletedAnyCharacters._64[pos >> CONST_LOG_2(64)] |= (static_cast<uint64_t>(1) << (pos & 63));
     772                #else
     773                deletedAnyCharacters._32[pos >> CONST_LOG_2(32)] |= (static_cast<uint32_t>(1) << (pos & 31));
     774                #endif
     775            }
     776        }
     777    }
     778    else // if (fScanner.getXMLVersion() == XMLReader::XMLV1_1) // can only be this; would be a decl error otherwise
     779    {
     780        // do XML 1.1 specific end of line normalization
     781        while (unlikely(crItr.next()))
     782        {
     783            pos = crItr.pos();
     784            bufToFill[pos++] = chLF;
     785            // did this buffer end with a CR?
     786            if (unlikely(pos == kCharBufSize))
     787            {
     788                // push back the CR just to be sure that we arent dealing with a CRLF
     789                bytesEaten -= charSizes[--charsDone];
     790                DEBUG_MESSAGE(" -- pushback(CR)")
     791                break;
     792            }
     793            if (unlikely((bufToFill[pos] == chLF) || (bufToFill[pos] == chNEL)))
     794            {
     795                // if we found a {CR,LF} or a {CR,NEL}, then mark the LF/NEL for deletion
     796                #ifdef __ARCH_64
     797                deletedAnyCharacters._64[pos >> CONST_LOG_2(64)] |= (static_cast<uint64_t>(1) << (pos & 63));
     798                #else
     799                deletedAnyCharacters._32[pos >> CONST_LOG_2(32)] |= (static_cast<uint32_t>(1) << (pos & 31));
     800                #endif
     801            }
     802        }
     803
     804        XMLChIterator2<chNEL, chLineSeparator> nonLfItr(bufToFill, charsDone);
     805        while (unlikely(nonLfItr.next()))
     806        {
     807            bufToFill[nonLfItr.pos()] = chLF;
     808        }
     809    }
     810
     811    // remove all deleted characters from the semi-final production
     812    if (unlikely(bitblock::any(deletedAnyCharacters._128)))
     813    {
     814        XMLStreamIterator itr(deletedAnyCharacters);
     815        // get the position of the first deleted character
     816        itr.next();
     817        size_t outputPos = itr.pos();
     818        size_t lastPos;
     819        // now scan for any other deleted characters
     820        for (; lastPos = itr.pos() + 1, itr.next(); )
     821        {
     822            const size_t len = itr.pos() - lastPos;
     823            charSizes[outputPos - 1] += charSizes[lastPos - 1];
     824            Array<unsigned char>::move(&charSizes[lastPos], &charSizes[outputPos], len);
     825
     826            Array<XMLCh>::move(&bufToFill[lastPos], &bufToFill[outputPos], len);
     827
     828            outputPos += len;
     829        }
     830        // no more deleted characters; just append the remainder of the string
     831        const size_t len = charsDone - lastPos;
     832        charSizes[outputPos - 1] += charSizes[lastPos - 1];
     833        Array<unsigned char>::move(&charSizes[lastPos], &charSizes[outputPos], len);
     834        Array<XMLCh>::move(&bufToFill[lastPos], &bufToFill[outputPos], len);               
     835        charsDone = outputPos + len;
     836    }
     837}
     838
     839inline void XMLReader::handleEOL(XMLCh & curCh, bool inDecl)
     840{
     841    // Handle line/col tracking for any character-at-a-time parsing modes.
     842    if (unlikely(inDecl))
     843    {
     844        if (curCh == chNEL || curCh == chLineSeparator)
     845        {
     846            /***
     847             * XML1.1
     848             *
     849             * 2.11 End-of-Line Handling
     850             *  ...
     851             *   The characters #x85 and #x2028 cannot be reliably recognized and translated
     852             *   until an entity's encoding declaration (if present) has been read.
     853             *   Therefore, it is a fatal error to use them within the XML declaration or
     854             *   text declaration.
     855             *
     856             ***/
     857            ThrowXMLwithMemMgr1
     858            (
     859                TranscodingException
     860                , XMLExcepts::Reader_NelLsepinDecl
     861                , fSystemId
     862                , fMemoryManager
     863            );
     864        }
     865    }
     866
     867    if (unlikely(curCh == chLF))
     868    {
     869        fCurCol = 1;
     870        fCurLine++;
     871    }
     872    else
     873    {
     874        fCurCol++;
     875    }
     876}
     877
     878inline XMLSize_t XMLReader::calculateRawBufIndex()
     879{
     880    // See if we have any existing chars.
     881    XMLSize_t spareChars = fCharsAvail - fCharIndex;
     882    XMLSize_t rawBufIndex = fRawBufIndex;
     883    //
     884    //  If there are spare chars, then adjust the raw buffer index
     885    //
     886    if (spareChars)
     887    {
     888        XMLSize_t offset = fCharSizeBuf[fCharIndex];
     889        for (XMLSize_t index = fCharIndex + 1; --spareChars; index++)
     890        {
     891            offset += fCharSizeBuf[index];
     892        }
     893        rawBufIndex -= offset;
     894        DEBUG_MESSAGE(" --- fRawBufIndex'=" << fRawBufIndex)
     895    }
     896    return rawBufIndex;
     897}
     898
    760899// ---------------------------------------------------------------------------------------
    761900
     
    772911XMLReader::scanDocument( XMLScannerType * const scanner )
    773912{
     913    DEBUG_MESSAGE("XMLReader::scanDocument()")
     914
    774915    // construct the actual XMLParser object to parse the ELEMENT and MISC nodes
    775     XMLParserImpl<XMLScannerType>
    776         parser
    777         (
    778             scanner
    779             , fMemoryManager
    780         );
     916    XMLParserImpl<XMLScannerType> parser(scanner, fMemoryManager);
    781917
    782918    //  Scan the PROLOG part, which is everything before the root element
     
    791927    }
    792928
     929    refreshRawBuffer(calculateRawBufIndex(), 0);
     930
    793931    parser.init(fCharacterSetAdapter, fTranscoder, fCurLine, fCurCol, fXMLVersion);
    794932
     
    797935        CALLGRIND_START_INSTRUMENTATION;
    798936
    799         register XMLSize_t offset = fSrcOfsBase;
    800         for (XMLSize_t i = 0; i < fCharIndex; i++)
    801         {
    802                 offset += fCharSizeBuf[i];
    803         }
    804 
    805         refreshRawBuffer(offset, 0);
    806 
    807         // transform the new raw data into symbol and content streams
    808         parser.preScanDocumentPage
    809         (
    810                 fRawByteBuf
    811                 , fRawBytesAvail
    812                 , fRawBytesRead <= kRawBufSize
    813                 , this
    814         );
    815 
    816         DEBUG_TRANSITION_MESSAGE("######################################################################");
    817         DEBUG_TRANSITION_MESSAGE("SCANNING ELEMENT(S)")
    818         DEBUG_TRANSITION_MESSAGE("######################################################################");
    819 
    820     while (likely(parser.scanElementPage()))
    821         {
    822                 parser.prepareForNextDocumentPage();
    823 
    824                 // transform the new raw data into symbol and content streams
    825                 parser.preScanDocumentPage
    826                 (
    827                         fRawByteBuf
    828                         , fRawBytesAvail
    829                         , fRawBytesRead <= kRawBufSize
    830                         , this
    831                 );
    832         }
     937    DEBUG_TRANSITION_MESSAGE("######################################################################");
     938    DEBUG_TRANSITION_MESSAGE("SCANNING ELEMENT(S)")
     939    DEBUG_TRANSITION_MESSAGE("######################################################################");
     940
     941    for (;;)
     942    {
     943        // transform the new raw data into symbol and content streams
     944        parser.preScanDocumentPage(fRawByteBuf, fRawBytesAvail, fEOF, this);
     945
     946        parser.buildElementPage();
     947
     948        if (unlikely(!parser.scanElementPage())) break;
     949
     950        parser.prepareForNextDocumentPage();
     951    }
    833952
    834953    DEBUG_TRANSITION_MESSAGE("######################################################################");
     
    841960
    842961        // transform the new raw data into symbol and content streams
    843         parser.preScanDocumentPage
    844         (
    845             fRawByteBuf
    846             , fRawBytesAvail
    847             , fRawBytesRead <= kRawBufSize
    848             , this
    849         );
     962        parser.preScanDocumentPage(fRawByteBuf, fRawBytesAvail, fEOF, this);
    850963    }
    851964
     
    865978template <class XMLScannerType>
    866979IDISA_ALWAYS_INLINE
    867 XMLParserImpl<XMLScannerType> *
    868 XMLReader::scanFirst( XMLScannerType * const scanner )
    869 {
     980void XMLReader::scanFirst( XMLScannerType * const scanner )
     981{
     982    DEBUG_MESSAGE("XMLReader::scanFirst()")
     983
    870984    // construct the actual XMLParser object to parse the ELEMENT and MISC nodes
    871     XMLParserImpl<XMLScannerType> * parser =
    872         new XMLParserImpl<XMLScannerType>
    873         (
    874             scanner
    875             , fMemoryManager
    876         );
     985    XMLParserImpl<XMLScannerType> * parser = new XMLParserImpl<XMLScannerType>(scanner, fMemoryManager);
    877986
    878987    //  Scan the PROLOG part, which is everything before the root element
     
    884993        {
    885994                scanner->emitError(XMLErrs::BadXMLEncoding, fEncodingStr);
    886                 return 0;
     995        return;
    887996        }
    888997
     998    refreshRawBuffer(calculateRawBufIndex(), 0);
     999
    8891000    parser->init(fCharacterSetAdapter, fTranscoder, fCurLine, fCurCol, fXMLVersion);
    8901001
    891         fParser = (XMLParser*)parser;
    892 
    893         XMLSize_t offset = fSrcOfsBase;
    894         for (XMLSize_t i = 0; i < fCharIndex; i++)
    895         {
    896                 offset += fCharSizeBuf[i];
    897         }
    898         refreshRawBuffer(offset, 0);
     1002    fParser = reinterpret_cast<XMLParser*>(parser);
    8991003
    9001004        // transform the new raw data into symbol and content streams
    901         parser->preScanDocumentPage
    902         (
    903                 fRawByteBuf
    904                 , fRawBytesAvail
    905                 , fRawBytesRead <= kRawBufSize
    906                 , this
    907         );
    908 
    909         fNoMore = false;
    910 
    911         DEBUG_TRANSITION_MESSAGE("######################################################################");
    912         DEBUG_TRANSITION_MESSAGE("SCANNING ELEMENT(S)")
    913         DEBUG_TRANSITION_MESSAGE("######################################################################");
    914 
    915         return parser;
     1005    parser->preScanDocumentPage(fRawByteBuf, fRawBytesAvail, fEOF, this);
     1006
     1007    parser->buildElementPage();
    9161008}
    9171009
     
    9201012template <class XMLScannerType>
    9211013IDISA_ALWAYS_INLINE
    922 bool XMLReader::scanNext(XMLParserImpl<XMLScannerType> & parser)
    923 {
    924         if (unlikely(fNoMore)) return 0;
    925 
    926     XMLParser::XMLScanState r = parser.scanNext();
    927 
    928         if (unlikely(r != XMLParser::HasMoreData))
    929         {
    930                 if (likely(r == XMLParser::EndOfPage))
    931                 {           
    932                         if (unlikely(fRawBytesAvail == 0))
    933                         {
    934                                 fNoMore = 1;
    935                                 fParser = 0;
    936                                 return 0;
    937                         }
    938 
    939             if (unlikely(fRawBytesRead <= kRawBufSize))
    940             {
    941                 fNoMore = 1;
    942                 fParser = 0;
    943                 return 0;
    944             }
    945 
    946                         parser.prepareForNextDocumentPage();
    947 
    948                         parser.preScanDocumentPage
    949                         (
    950                                 fRawByteBuf
    951                                 , fRawBytesAvail
    952                                 , fRawBytesRead <= kRawBufSize
    953                                 , this
    954                         );
    955 
    956             parser.preScanElementPage();
    957                 }
    958                 else
    959                 {
    960                         DEBUG_TRANSITION_MESSAGE("######################################################################");
    961                         DEBUG_TRANSITION_MESSAGE("SCANNING MISCELLANEOUS")
    962                         DEBUG_TRANSITION_MESSAGE("######################################################################");
    963 
    964             while (unlikely(parser.scanMiscellaneousPage()))
    965                         {
    966                                 // if there is no new data; we're done (and the file is likely in error)
    967                                 if (likely(fRawBytesRead <= kRawBufSize)) break;
    968 
    969                                 parser.prepareForNextDocumentPage();
    970 
    971                                 // transform the new raw data into symbol and content streams
    972                                 parser.preScanDocumentPage
    973                                 (
    974                                         fRawByteBuf
    975                                         , fRawBytesAvail
    976                                         , fRawBytesRead <= kRawBufSize
    977                                         , this
    978                                 );
    979                         }
    980 
    981                         fNoMore = 1;
    982                         fParser = 0;
    983                         return 0;
    984                 }
    985     }
    986         return 1;
     1014bool XMLReader::scanNext()
     1015{
     1016    XMLParserImpl<XMLScannerType> * const parser = reinterpret_cast<XMLParserImpl<XMLScannerType>*>(fParser);
     1017
     1018    if (likely(parser->scanNext()))
     1019    {
     1020        return true;
     1021    }
     1022
     1023    if (likely(parser->inElement()))
     1024    {
     1025        DEBUG_MESSAGE(" **** CONTINUE ELEMENT SPAN **** ")
     1026
     1027        parser->prepareForNextDocumentPage();
     1028
     1029        parser->preScanDocumentPage(fRawByteBuf, fRawBytesAvail, fEOF, this);
     1030
     1031        parser->buildElementPage();
     1032
     1033        if (likely(parser->scanNext()))
     1034        {
     1035            return true;
     1036        }
     1037    }
     1038
     1039    DEBUG_MESSAGE(" **** BEGIN MISCELLANEOUS SPAN **** ")
     1040
     1041    while (unlikely(parser->scanMiscellaneousPage()))
     1042    {
     1043        // if there is no new data; we're done (and the file is likely in error)
     1044        if (likely(fEOF)) break;
     1045
     1046        parser->prepareForNextDocumentPage();
     1047
     1048        // transform the new raw data into symbol and content streams
     1049        parser->preScanDocumentPage(fRawByteBuf, fRawBytesAvail, fEOF, this);
     1050    }
     1051
     1052    delete fParser;
     1053    fParser = 0;
     1054    fNoMore = true;
     1055    return 0;
    9871056}
    9881057
     
    10261095}
    10271096
     1097inline bool XMLReader::isPlainContentChar(const XMLCh toCheck) const
     1098{
     1099    DEPRECATED_FEATURE_IN_ICXML;
     1100}
     1101
     1102inline bool XMLReader::isSpecialStartTagChar(const XMLCh toCheck) const
     1103{
     1104    DEPRECATED_FEATURE_IN_ICXML;
     1105}
     1106
    10281107#undef CHAR_SIZE
    10291108#undef SYMBOL_POSITION
  • icXML/icXML-devel/src/icxercesc/internal/XMLScanner.cpp

    r3104 r3150  
    518518                //  including the DTD subsets. This is all that is done on the scan
    519519                //  first.
    520                 scanProlog();
    521 
    522                 //  If we got to the end of input, then its not a valid XML file.
    523                 //  Else, go on to scan the content.
    524                 if (fReaderMgr.atEOF())
    525                 {
    526                         emitError(XMLErrs::EmptyMainEntity);
    527                 }
     520        scanFirst();
    528521        }
    529522        //  NOTE:
     
    599592        // more to scan.
    600593        resetReaderMgr.release();
    601 
    602         // Instruct this scanner to construct and initialize a progressive parser
    603         scanFirst();
    604594
    605595        return true;
     
    694684        fMemoryManager->deallocate(fExternalSchemaLocation);
    695685        fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);
     686    fMemoryManager->deallocate(fRootElemName);
    696687}
    697688
     
    17751766        const XMLCh nextCh = fReaderMgr.peekNextChar();
    17761767
    1777         DEBUG_MESSAGE(" -- nextCh=" << nextCh << ' ' << (char)nextCh)
    1778 
    17791768        if (nextCh == chOpenAngle)
    17801769        {
     
    17931782                }
    17941783
    1795                 DEBUG_MESSAGE("XMLScanner::scanXMLDecl()")
    17961784                scanXMLDecl(Decl_XML);
    17971785            }
    17981786            else if (fReaderMgr.skippedString(XMLUni::fgPIString))
    17991787            {
    1800                 DEBUG_MESSAGE("XMLScanner::scanPI()")
    18011788                scanPI();
    18021789                seenAnything = true;
     
    18041791            else if (fReaderMgr.skippedString(XMLUni::fgCommentString))
    18051792            {
    1806                 DEBUG_MESSAGE("XMLScanner::scanComment()")
    18071793                scanComment();
    18081794                seenAnything = true;
     
    18101796            else if (fReaderMgr.skippedString(XMLUni::fgDocTypeString))
    18111797            {
    1812                 DEBUG_MESSAGE("XMLScanner::scanDocTypeDecl()")
    18131798                if (sawDocTypeDecl)
    18141799                {
     
    18291814            {
    18301815                // Assume its the start of the root element
     1816
     1817                //  If we got to the end of input, then its not a valid XML file.
     1818                //  Else, go on to scan the content.
     1819                if (fReaderMgr.atEOF())
     1820                {
     1821                    emitError(XMLErrs::EmptyMainEntity);
     1822                }
    18311823                break;
    18321824            }
    18331825        }
    1834         else if (fReaderMgr.getCurrentReader()->isWhitespace(nextCh))
     1826        else if (XMLNameChar::isWhitespace(nextCh, true))
    18351827        {
    18361828            //  If we have a document handler then gather up the
     
    18391831            {
    18401832                fReaderMgr.getSpaces(bbCData.getBuffer());
    1841                 fDocHandler->ignorableWhitespace
    1842                 (
    1843                     bbCData.getRawBuffer()
    1844                     , bbCData.getLen()
    1845                     , false
    1846                 );
     1833                fDocHandler->ignorableWhitespace(bbCData.getRawBuffer(), bbCData.getLen(), false);
    18471834            }
    18481835            else
     
    19161903    , XMLBuffer &                   /* toFill */
    19171904    , bool      &                   /* isPredefined */
    1918     , XMLReader::XMLVersion &       /* version */
     1905    , bool      &                   /* isExternal */
    19191906    , XMLFileLoc &                  /* line */
    19201907    , XMLFileLoc &                  /* column */
  • icXML/icXML-devel/src/icxercesc/internal/XMLScanner.hpp

    r3104 r3150  
    555555        , XMLBuffer &                   toFill
    556556        , bool      &                   isPredefined
    557         , XMLReader::XMLVersion &       version
     557        , bool      &                   isExternal
    558558        , XMLFileLoc &                  line
    559559        , XMLFileLoc &                  column
     
    656656                , const int                 prefixColonPos
    657657        );
     658
     659    void popReader();
    658660
    659661        // -----------------------------------------------------------------------
     
    16181620}
    16191621
     1622inline void XMLScanner::popReader()
     1623{
     1624    fReaderMgr.popReader();
     1625}
     1626
    16201627// ---------------------------------------------------------------------------
    16211628//  DEPRECATED BUT KEPT FOR DLL COMPATIBILITY
  • icXML/icXML-devel/src/icxercesc/util/QName.cpp

    r2721 r3150  
    1414#include <icxercesc/util/QName.hpp>
    1515#include <xercesc/util/OutOfMemoryException.hpp>
     16#include <icxmlc/XMLConfig.hpp>
    1617
    1718XERCES_CPP_NAMESPACE_BEGIN
     
    1920#pragma warning if we can map identical prefixes to one pool and indentical suffixes to another, it would make qualified comparisons easier
    2021
    21 #ifndef USE_SMART_QNAME_MANAGER
     22// #define USE_SHALLOW_CLONES
     23
    2224// ---------------------------------------------------------------------------
    2325//  QName: Constructors and Destructor
    2426// ---------------------------------------------------------------------------
    2527QName::QName(MemoryManager* const manager)
    26 :fNameBuf(0)
    27 ,fRawBufSz(0)
    28 ,fURIId(-1)
    29 ,fPrefix(0)
    30 ,fPrefixLen(0)
    31 ,fLocalPart(0)
    32 ,fLocalPartLen(0)
    33 ,fRawName(0)
    34 ,fMemoryManager(manager)
    35 {
    36 
     28: fNameBuf(0)
     29, fURIId(-1)
     30, fPrefix(0)
     31, fPrefixLen(0)
     32, fLocalPart(0)
     33, fLocalPartLen(0)
     34, fRawName(0)
     35, fMemoryManager(manager)
     36{
     37    assert (fMemoryManager);
    3738}
    3839
     
    4647        , MemoryManager* const manager
    4748)
    48         :fNameBuf(0)
    49         ,fRawBufSz(0)
     49        :fNameBuf(0)   
    5050        ,fURIId(-1)
    5151        ,fPrefix(0)
     
    8282)
    8383        :fNameBuf(0)
    84         ,fRawBufSz(0)
    8584        ,fURIId(-1)
    8685        ,fPrefix(0)
     
    120119)
    121120        :fNameBuf(0)
    122         ,fRawBufSz(0)
    123121        ,fURIId(-1)
    124122        ,fPrefix(0)
     
    147145        cleanup.release();
    148146}
     147
     148QName::~QName()
     149{
     150    DEBUG_MESSAGE(" --- ~QName() 0x" << std::hex << (size_t)(this) << " fNameBuf=0x" << (size_t)(fNameBuf) << std::dec);
     151        cleanUp();
     152}
     153
     154// ---------------------------------------------------------------------------
     155//  QName: Copy Constructors
     156// ---------------------------------------------------------------------------
     157#ifdef USE_SHALLOW_CLONES
     158QName::QName(const QName & qName)
     159: XSerializable(qName)
     160, XMemory(qName)
     161, fURIId(qName.fURIId)
     162, fPrefix(qName.fPrefix)
     163, fPrefixLen(qName.fPrefixLen)
     164, fLocalPart(qName.fLocalPart)
     165, fLocalPartLen(qName.fLocalPartLen)
     166, fRawName(qName.fRawName)
     167, fNameBuf(qName.fNameBuf)
     168, fMemoryManager(qName.fMemoryManager)
     169{
     170    DEBUG_MESSAGE(" --- QName(qName) 0x" << std::hex << (size_t)(this) << " fNameBuf=0x" << (size_t)(fNameBuf) << std::dec);
     171    // prevent the 'cloned' qname from deleting the memory for this qname
     172    const_cast<QName&>(qName).fNameBuf = 0;
     173}
     174
     175QName & QName::operator=(const QName & qName)
     176{
     177    DEBUG_MESSAGE(" --- QName=qName 0x" << std::hex << (size_t)(this) << " fNameBuf=0x" << (size_t)(fNameBuf) << std::dec);
     178    // free up the original memory if need be
     179    cleanUp();
     180    // and 'clone' the supplied QName
     181    fURIId = qName.fURIId;
     182    fPrefix = qName.fPrefix;
     183    fPrefixLen = qName.fPrefixLen;
     184    fLocalPart = qName.fLocalPart;
     185    fLocalPartLen = qName.fLocalPartLen;
     186    fRawName = qName.fRawName;
     187    fNameBuf = qName.fNameBuf;
     188    fMemoryManager = qName.fMemoryManager;
     189    // prevent the 'cloned' qname from deleting the memory for this qname
     190    const_cast<QName&>(qName).fNameBuf = 0;
     191    return *this;
     192}
     193#else
     194QName::QName(const QName & qName)
     195: XSerializable(qName)
     196, XMemory(qName)
     197, fNameBuf(0)
     198, fURIId(-1)
     199, fPrefix(0)
     200, fPrefixLen(0)
     201, fLocalPart(0)
     202, fLocalPartLen(0)
     203, fRawName(0)
     204, fMemoryManager(qName.fMemoryManager)
     205{
     206    CleanupType cleanup(this, &QName::cleanUp);
     207    try
     208    {
     209        //
     210        //  Just call the local setters to set up everything. Too much
     211        //  work is required to replicate that functionality here.
     212        //
     213        setName(qName.fRawName, qName.fURIId);
     214    }
     215    catch(const OutOfMemoryException&)
     216    {
     217        cleanup.release();
     218        throw;
     219    }
     220
     221    cleanup.release();
     222}
     223
     224QName & QName::operator=(const QName & qName)
     225{
     226    CleanupType cleanup(this, &QName::cleanUp);
     227    try
     228    {
     229        fMemoryManager = qName.fMemoryManager;
     230        //
     231        //  Just call the local setters to set up everything. Too much
     232        //  work is required to replicate that functionality here.
     233        //
     234        setName(qName.fRawName, qName.fURIId);
     235    }
     236    catch(const OutOfMemoryException&)
     237    {
     238        cleanup.release();
     239        throw;
     240    }
     241
     242    cleanup.release();
     243    return *this;
     244}
    149245#endif
    150246
    151 QName::~QName()
    152 {
    153 #ifndef USE_SMART_QNAME_MANAGER
    154         cleanUp();
    155 #endif
    156 }
    157 
    158 // ---------------------------------------------------------------------------
    159 //  QName: Copy Constructors
    160 // ---------------------------------------------------------------------------
    161 #ifdef USE_SMART_QNAME_MANAGER
    162 QName::QName(const QName & qname)
    163 : XSerializable(qname)
    164 , XMemory(qname)
    165 , fURIId(qname.fURIId)
    166 , fPrefix(qname.fPrefix)
    167 , fPrefixLen(qname.fPrefixLen)
    168 , fLocalPart(qname.fLocalPart)
    169 , fLocalPartLen(qname.fLocalPartLen)
    170 , fRawName(qname.fRawName)
    171 {
    172 
    173 
    174 }
    175 #else
    176 QName::QName(const QName & qname)
    177         :XSerializable(qname)
    178         ,XMemory(qname)
    179         ,fNameBuf(0)
    180         ,fRawBufSz(0)
    181         ,fURIId(-1)
    182         ,fPrefix(0)
    183         ,fPrefixLen(0)
    184         ,fLocalPart(0)
    185         ,fLocalPartLen(0)
    186         ,fRawName(0)
    187         ,fMemoryManager(qname.fMemoryManager)
    188 {
    189 
    190         CleanupType cleanup(this, &QName::cleanUp);
    191 
    192         try
    193         {
    194                 //
    195                 //  Just call the local setters to set up everything. Too much
    196                 //  work is required to replicate that functionality here.
    197                 //
    198                 setName(qname.fRawName, qname.fURIId);
    199         }
    200         catch(const OutOfMemoryException&)
    201         {
    202                 cleanup.release();
    203                 throw;
    204         }
    205 
    206         cleanup.release();
    207 }
    208 #endif
     247
    209248
    210249// ---------------------------------------------------------------------------
     
    262301        fMemoryManager->deallocate(fNameBuf);
    263302        fNameBuf = nameBuf;
    264 }
    265 
    266 
    267 void QName::setName(const XMLCh* const    prefix
    268                                   , const XMLCh* const    localPart
    269                                   , const unsigned int    uriId)
    270 {
    271 #ifndef USE_SMART_QNAME_MANAGER
     303
     304    DEBUG_MESSAGE(" --- QName::setName(" << rawName << ',' << colonInd << ',' << uriId << ") 0x" << std::hex << (size_t)(this) << " fNameBuf=0x" << (size_t)(fNameBuf) << std::dec);
     305}
     306
     307
     308void QName::setName
     309(
     310    const XMLCh* const      prefix
     311    , const XMLCh* const    localPart
     312    , const unsigned int    uriId
     313)
     314{
    272315        fPrefixLen = XMLString::stringLen(prefix);
    273316        fLocalPartLen = XMLString::stringLen(localPart);
     
    311354        fMemoryManager->deallocate(fNameBuf);
    312355        fNameBuf = nameBuf;
    313 #endif
     356
     357    DEBUG_MESSAGE(" --- QName::setName(" << prefix << ',' << localPart << ',' << uriId << ") 0x" << std::hex << (size_t)(this) << " fNameBuf=0x" << std::hex << (size_t)(fNameBuf) << std::dec);
    314358}
    315359
     
    334378bool QName::operator==(const QName& qname) const
    335379{
    336 #ifndef USE_SMART_QNAME_MANAGER
    337380        // if we are an unitialized QName, check that the other is unitialized too
    338381        if (!fLocalPart && !fPrefix)
     
    347390
    348391        return (fURIId == qname.getURI()) && (XMLString::equals(fLocalPart, qname.getLocalPart()));
    349 #else
    350         return (fURIId == qname.getURI()) && (fLocalPart == qname.getLocalPart());
    351 #endif
    352392}
    353393
     
    358398void QName::cleanUp()
    359399{
    360 #ifndef USE_SMART_QNAME_MANAGER
    361         if (fMemoryManager) fMemoryManager->deallocate(fNameBuf);
    362         fLocalPart = fPrefix = fRawName = fNameBuf = 0;
    363 #endif
     400    if (fNameBuf)
     401    {
     402        assert (fMemoryManager);
     403        fMemoryManager->deallocate(fNameBuf);
     404        fNameBuf = 0;
     405    }
    364406}
    365407
     
    367409 * Support for Serialization/De-serialization
    368410 ***/
    369 
    370411IMPL_XSERIALIZABLE_TOCREATE(QName)
    371412
    372 void QName::serialize(XSerializeEngine& serEng)
    373 {
    374         XMLSize_t fPrefixBufSz;
    375         XMLSize_t fLocalPartBufSz;
    376 
    377         if (serEng.isStoring())
    378         {
    379                 XMLSize_t fPrefixBufSz = XMLString::stringLen(fPrefix);
    380                 XMLSize_t fLocalPartBufSz = XMLString::stringLen(fLocalPart);
    381 
    382                 serEng.writeString(fPrefix, fPrefixBufSz, XSerializeEngine::toWriteBufferLen);
    383 
    384                 serEng.writeString(fLocalPart, fLocalPartBufSz, XSerializeEngine::toWriteBufferLen);
    385 
    386                 //do not serialize rawName
    387 
    388                 serEng<<fURIId;
    389         }
    390         else
    391         {
    392                 XMLSize_t dataLen = 0;
    393 
    394                 serEng.readString(fPrefix, fPrefixBufSz, dataLen, XSerializeEngine::toReadBufferLen);
    395 
    396                 serEng.readString(fLocalPart, fLocalPartBufSz, dataLen, XSerializeEngine::toReadBufferLen);
    397 
    398                 serEng>>fURIId;
    399 
    400                 setName(this->fPrefix, this->fLocalPart, this->fURIId);
    401         }
     413void QName::serialize(XSerializeEngine&)
     414{
     415    DEPRECATED_FEATURE_IN_ICXML;
    402416}
    403417
  • icXML/icXML-devel/src/icxercesc/util/QName.hpp

    r2721 r3150  
    3030
    3131    friend class XMLSymbolTable;
     32    friend class XMLSymbol;
    3233
    3334        // NOTE: need to deprecate these later instead...
     
    138139        DECL_XSERIALIZABLE(QName)
    139140
     141protected:
     142
     143    QName& operator=(const QName&);
     144
    140145private :
    141         // -----------------------------------------------------------------------
    142         //  Unimplemented constructors and operators
    143         // -----------------------------------------------------------------------
    144         QName& operator=(const QName&);
     146
    145147
    146148        // -----------------------------------------------------------------------
     
    151153        //
    152154        //  fPrefix
    153         //  fPrefixBufSz
     155    //  fPrefixLen
    154156        //      The prefix that was applied to this attribute's name, and the
    155157        //      current size of the buffer (minus one for the null.) Prefixes
     
    158160        //
    159161        //  fLocalPart
    160         //  fLocalPartBufSz
     162    //  fLocalPartLen
    161163        //      The base part of the name of the attribute, and the current size
    162164        //      of the buffer (minus one, where the null is.)
    163165        //
    164         //  fFullName
    165         //  fRawNameBufSz
     166    //  fRawName
    166167        //      This is the QName form of the name, which is faulted in (from the
    167168        //      prefix and name) upon request. The size field indicates the
     
    174175        unsigned int        fURIId;
    175176
    176         #ifndef USE_SMART_QNAME_MANAGER
    177177        XMLCh*              fNameBuf;
    178         XMLSize_t           fRawBufSz;
    179         #endif
    180178
    181179        XMLCh*              fPrefix;
     
    188186
    189187
    190         #ifndef USE_SMART_QNAME_MANAGER
    191188        MemoryManager*      fMemoryManager;
    192         #endif
    193189};
    194190
  • icXML/icXML-devel/src/icxercesc/util/XMLUTF8Transcoder.cpp

    r3103 r3150  
    229229                XMLUInt32 tmpVal = 0;
    230230
    231                 switch(trailingBytes)
     231        switch (trailingBytes)
    232232                {
    233233                        case 1 :
     
    370370                //  replacement char.
    371371                //
    372                 if (!(tmpVal & 0xFFFF0000))
     372        if (likely(tmpVal <= 0xFFFF))
    373373                {
    374374                        *sizePtr++ = trailingBytes + 1;
    375375                        *outPtr++ = XMLCh(tmpVal);
    376376                }
    377                 else if (tmpVal > 0x10FFFF)
     377        else if (tmpVal > 0x10FFFF)
    378378                {
    379379                        //
     
    671671        //  replacement char.
    672672        //
    673         if (!(tmpVal & 0xFFFF0000))
     673        if (tmpVal <= 0xFFFF)
    674674        {
    675675            *outPtr++ = XMLCh(tmpVal);
    676676        }
    677          else if (tmpVal > 0x10FFFF)
     677        else if (tmpVal > 0x10FFFF)
    678678        {
    679679            //
  • icXML/icXML-devel/src/icxercesc/validators/DTD/DTDAttDef.cpp

    r3103 r3150  
    3333//  DTDAttDef: Constructors and Destructor
    3434// ---------------------------------------------------------------------------
    35 DTDAttDef::DTDAttDef(MemoryManager* const manager) :
     35DTDAttDef::DTDAttDef(MemoryManager* const manager)
     36: XMLAttDef(XMLAttDef::CData, XMLAttDef::Implied, manager)
     37, fElemId(XMLElementDecl::fgInvalidElemId)
     38, fAttName(0)
     39{
    3640
    37         XMLAttDef(XMLAttDef::CData, XMLAttDef::Implied, manager)
    38    , fElemId(XMLElementDecl::fgInvalidElemId)
    39         , fAttName(0)
    40 {
    4141}
    4242
     
    4545                                        , const XMLAttDef::DefAttTypes defType
    4646                                        , MemoryManager* const         manager) :
    47         XMLAttDef(type, defType, manager)
    48         , fElemId(XMLElementDecl::fgInvalidElemId)
    49         , fAttName(0)
     47XMLAttDef(type, defType, manager)
     48, fElemId(XMLElementDecl::fgInvalidElemId)
     49, fAttName(new (manager) QName(attName, XMLNamespaceResolver::fEmptyUriId, manager))
    5050{
    51         fAttName = new (manager) QName(attName, XMLNamespaceResolver::fEmptyUriId, manager);
     51
    5252}
    5353
     
    5959                                        , MemoryManager* const         manager) :
    6060
    61         XMLAttDef(attValue, type, defType, enumValues, manager)
    62         , fElemId(XMLElementDecl::fgInvalidElemId)
    63         , fAttName(0)
     61XMLAttDef(attValue, type, defType, enumValues, manager)
     62, fElemId(XMLElementDecl::fgInvalidElemId)
     63, fAttName(new (manager) QName(attName, XMLNamespaceResolver::fEmptyUriId, manager))
    6464{
    65         fAttName = new (manager) QName(attName, XMLNamespaceResolver::fEmptyUriId, manager);
     65
    6666}
    6767
     
    7777void DTDAttDef::setName(const XMLCh* const newName)
    7878{
    79         DEPRECATED_FEATURE_IN_ICXML;
     79    delete fAttName;
     80    fAttName = new (getMemoryManager()) QName(newName, XMLNamespaceResolver::fEmptyUriId, getMemoryManager());
    8081}
    8182
  • icXML/icXML-devel/src/icxercesc/validators/DTD/DTDAttDefList.cpp

    r3104 r3150  
    4848DTDAttDefList::~DTDAttDefList()
    4949{
    50     (getMemoryManager())->deallocate(fArray);
     50    for (XMLSize_t index = 0; index < fCount; index++)
     51    {
     52        delete fArray[index];
     53    }
     54    getMemoryManager()->deallocate(fArray);
    5155}
    52 
    5356
    5457// ---------------------------------------------------------------------------
  • icXML/icXML-devel/src/icxercesc/validators/DTD/DTDElementDecl.cpp

    r3104 r3150  
    8484        delete fContentSpec;
    8585        delete fContentModel;
    86     if (fFormattedModel) getMemoryManager()->deallocate(fFormattedModel);
     86    getMemoryManager()->deallocate(fFormattedModel);
    8787}
    8888
     
    214214                cmRet = new (getMemoryManager()) MixedContentModel(true, this->getContentSpec(), false, getMemoryManager());
    215215        }
    216         else if (fModelType == Children)
     216    else if (fModelType == Children)
    217217        {
    218218                //
     
    225225                cmRet = createChildModel();
    226226        }
    227         else
     227    else
    228228        {
    229229                ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_MustBeMixedOrChildren, getMemoryManager());
     
    245245        //  if it was, it should have already gotten taken by the Mixed model.
    246246        //
    247         if (specNode->getElement()) {
     247    if (specNode->getElement())
     248    {
    248249                if (specNode->getElement()->getURI() == XMLElementDecl::fgPCDataElemId)
    249250                        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_NoPCDATAHere, getMemoryManager());
     
    266267                );
    267268        }
    268          else if ((specNode->getType() == ContentSpecNode::Choice)
    269                   ||  (specNode->getType() == ContentSpecNode::Sequence))
     269    else if ((specNode->getType() == ContentSpecNode::Choice) || (specNode->getType() == ContentSpecNode::Sequence))
    270270        {
    271271                //
  • icXML/icXML-devel/src/icxercesc/validators/DTD/DTDElementDecl.hpp

    r3104 r3150  
    199199inline XMLContentModel* DTDElementDecl::getContentModel()
    200200{
    201         if (!fContentModel)
     201    if (unlikely(!fContentModel))
     202    {
    202203                fContentModel = makeContentModel();
     204    }
    203205        return fContentModel;
    204206}
  • icXML/icXML-devel/src/icxercesc/validators/DTD/DTDScanner.cpp

    r3104 r3150  
    117117    , fScanner(0)
    118118    , fPEntityDeclPool(0)
    119     , fEmptyNamespaceId(0)
     119    , fEmptyNamespaceId(XMLNamespaceResolver::fEmptyUriId)
    120120    , fDocTypeReaderId(0)
     121    , fXMLVersion1_0(false)
    121122{
    122123    fPEntityDeclPool = new (fMemoryManager) NameIdPool<DTDEntityDecl>(109, 128, fMemoryManager);
     
    139140    fReaderMgr = readerMgr;
    140141    fBufMgr = bufMgr;
    141 
    142     if (fScanner->getDoNamespaces())
    143         fEmptyNamespaceId = fScanner->getEmptyNamespaceId();
    144     else
    145         fEmptyNamespaceId = XMLNamespaceResolver::fEmptyUriId;
    146 
     142    fXMLVersion1_0 = (owningScanner->getXMLVersion() == XMLReader::XMLV1_0);
    147143    fDocTypeReaderId = fReaderMgr->getCurrentReaderNum();
    148144}
     
    338334        }
    339335    }
    340      else
     336    else
    341337    {
    342338        // Create a reader over a memory stream over the entity value
     
    426422
    427423        // Use the dummy decl to parse into and set its name to the name we got
    428         dummyDecl.fAttName = new QName(*decl->fAttName);
     424        dummyDecl.setName(decl->getFullName());
    429425        dummyDecl.setId(fNextAttrId++);
    430426        decl = &dummyDecl;
     
    437433        //  available unique id, and add it
    438434        //
    439         decl = new (fGrammarPoolMemoryManager) DTDAttDef
    440         (
    441             bufToUse.getRawBuffer()
    442             , XMLAttDef::CData
    443             , XMLAttDef::Implied
    444             , fGrammarPoolMemoryManager
    445         );
     435        decl = new (fGrammarPoolMemoryManager) DTDAttDef(bufToUse.getRawBuffer(), XMLAttDef::CData, XMLAttDef::Implied, fGrammarPoolMemoryManager);
    446436        decl->setId(fNextAttrId++);
    447437        decl->setExternalAttDeclaration(isReadingExternalEntity());
     
    579569    if (fDocTypeHandler)
    580570        fDocTypeHandler->attDef(parentElem, *decl, isIgnored);
     571
    581572    return decl;
    582573}
     
    655646            break;
    656647        }
    657          else if (fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
     648         else if (isWhitespace(nextCh))
    658649        {
    659650            //
     
    677668            }
    678669        }
    679          else if (nextCh == chPercent)
     670        else if (nextCh == chPercent)
    680671        {
    681672            // Eat the percent and expand the ref
     
    683674            expandPERef(false, false, true);
    684675        }
    685          else
     676        else
    686677        {
    687678            //
     
    736727                                , const XMLAttDef::AttTypes type)
    737728{
     729    DEBUG_MESSAGE("scanAttValue(" << attrName << ",," << type << ')')
     730
    738731    enum States
    739732    {
     
    822815                }
    823816                // Its got to at least be a valid XML character
    824                 else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh))
     817                else if (!isXMLChar(nextCh))
    825818                {
    826819                    XMLCh tmpBuf[9];
     
    872865                if (curState == InWhitespace)
    873866                {
    874                     if (!fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
     867                    if (!isWhitespace(nextCh))
    875868                    {
    876869                        if (firstNonWS)
     
    886879                 else if (curState == InContent)
    887880                {
    888                     if (fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
     881                    if (isWhitespace(nextCh))
    889882                    {
    890883                        curState = InWhitespace;
     
    920913{
    921914    bool gotOne = false;
    922     unsigned int value = 0;
     915    XMLUInt64 value = 0;
     916
     917    DEBUG_MESSAGE("scanCharRef(...)")
    923918
    924919    //
     
    927922    //  for that.
    928923    //
    929     unsigned int radix = 10;
     924    size_t radix = 10;
    930925
    931926    if (fReaderMgr->skippedChar(chLatin_x))
     
    933928        radix = 16;
    934929    }
    935      else if (fReaderMgr->skippedChar(chLatin_X))
     930    else if (fReaderMgr->skippedChar(chLatin_X))
    936931    {
    937932        fScanner->emitError(XMLErrs::HexRadixMustBeLowerCase);
    938933        radix = 16;
    939934    }
     935
     936    static const uint8_t CONVERSION_TABLE[112] =
     937        { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
     938        , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
     939        , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
     940        ,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1
     941        , -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1
     942        , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
     943        , -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1
     944        };
    940945
    941946    while (true)
     
    958963        //  one.
    959964        //
    960         unsigned int nextVal;
    961         if ((nextCh >= chDigit_0) && (nextCh <= chDigit_9))
    962             nextVal = (unsigned int)(nextCh - chDigit_0);
    963         else if ((nextCh >= chLatin_A) && (nextCh <= chLatin_F))
    964             nextVal= (unsigned int)(10 + (nextCh - chLatin_A));
    965         else if ((nextCh >= chLatin_a) && (nextCh <= chLatin_f))
    966             nextVal = (unsigned int)(10 + (nextCh - chLatin_a));
    967         else
     965        uint8_t nextVal = CONVERSION_TABLE[nextCh];
     966        if (unlikely(nextVal == (uint8_t)-1))
    968967        {
    969968            //
     
    975974            else
    976975                fScanner->emitError(XMLErrs::ExpectedNumericalCharRef);
    977 
    978976            return false;
    979977        }
     
    984982        //  running value with this new digit.
    985983        //
    986         if (nextVal >= radix)
     984        if (unlikely(nextVal >= radix))
    987985        {
    988986            XMLCh tmpStr[2];
     
    991989            fScanner->emitError(XMLErrs::BadDigitForRadix, tmpStr);
    992990        }
    993          else
     991        else
    994992        {
    995993            value = (value * radix) + nextVal;
     
    998996        // Indicate that we got at least one good digit
    999997        gotOne = true;
    1000 
    1001998        // Eat the char we just processed
    1002999        fReaderMgr->getNextChar();
    10031000    }
    10041001
    1005     // Return the char (or chars)
    1006     // And check if the character expanded is valid or not
    1007     if (value >= 0x10000 && value <= 0x10FFFF)
    1008     {
     1002    // Check if the character expanded is valid or not and return the char
     1003    bool valid = false;
     1004    if (likely(value <= 0xFFFF))
     1005    {
     1006        valid = XMLNameChar::isXMLChar(value, fScanner->getXMLVersion() == XMLReader::XMLV1_0, true);
     1007        first  = XMLCh(value);
     1008        second = 0;
     1009    }
     1010    else if (value >= 0x10000 && value <= 0x10FFFF)
     1011    {
     1012        valid = true;
    10091013        value -= 0x10000;
    10101014        first  = XMLCh((value >> 10) + 0xD800);
    10111015        second = XMLCh((value & 0x3FF) + 0xDC00);
    10121016    }
    1013     else if (value <= 0xFFFD)
    1014     {
    1015         first  = XMLCh(value);
    1016         second = 0;
    1017         if (!fReaderMgr->getCurrentReader()->isXMLChar(first) && !fReaderMgr->getCurrentReader()->isControlChar(first)) {
    1018             // Character reference was not in the valid range
    1019             fScanner->emitError(XMLErrs::InvalidCharacterRef);
    1020             return false;
    1021         }
    1022     }
    1023     else {
     1017    if (unlikely(!valid))
     1018    {
    10241019        // Character reference was not in the valid range
    10251020        fScanner->emitError(XMLErrs::InvalidCharacterRef);
    1026         return false;
    1027     }
    1028 
    1029     return true;
     1021    }
     1022    return valid;
    10301023}
    10311024
     
    10371030    checkForPERef(false, true);
    10381031
    1039     ValueStackOf<XMLSize_t>* arrNestedDecl=NULL;
     1032    typedef ValueStackOf<XMLSize_t> ValueStackOfXMLSizeT;
     1033
     1034    Janitor<ValueStackOfXMLSizeT> janArrNestedDecl(NULL);
     1035    ValueStackOfXMLSizeT * arrNestedDecl = NULL;
     1036
    10401037    //
    10411038    //  We know that the caller just saw an opening parenthesis, so we need
     
    10511048        // to check entity nesting
    10521049        const XMLSize_t curReader = fReaderMgr->getCurrentReaderNum();
    1053         if(arrNestedDecl==NULL)
    1054             arrNestedDecl=new (fMemoryManager) ValueStackOf<XMLSize_t>(5, fMemoryManager);
     1050        if (!arrNestedDecl)
     1051        {
     1052            arrNestedDecl = new (fMemoryManager) ValueStackOf<XMLSize_t>(5, fMemoryManager);
     1053            janArrNestedDecl.reset(arrNestedDecl);
     1054        }
    10551055        arrNestedDecl->push(curReader);
    10561056
     
    11111111    }
    11121112
    1113     while(arrNestedDecl==NULL || !arrNestedDecl->empty())
     1113    while (arrNestedDecl==NULL || !arrNestedDecl->empty())
    11141114    {
    11151115        // Check for a PE ref here, but don't require spaces
     
    11241124        const XMLCh opCh = fReaderMgr->peekNextChar();
    11251125
    1126         if ((opCh != chComma)
    1127         &&  (opCh != chPipe)
    1128         &&  (opCh != chCloseParen))
     1126        if ((opCh != chComma) &&  (opCh != chPipe) && (opCh != chCloseParen))
    11291127        {
    11301128            // Not a legal char, so delete our node and return failure
     
    11561154            curNode = headNode;
    11571155        }
    1158          else if (opCh == chPipe)
     1156        else if (opCh == chPipe)
    11591157        {
    11601158            curType = ContentSpecNode::Choice;
     
    11701168            curNode = headNode;
    11711169        }
    1172          else
     1170        else // if (opCh == chCloseParen)
    11731171        {
    11741172            headNode = curNode;
     
    11961194                    checkForPERef(false, true);
    11971195                }
    1198                  else if (fReaderMgr->skippedSpace())
     1196                else if (fReaderMgr->skippedSpace())
    11991197                {
    12001198                    // Just skip whitespace
    12011199                    fReaderMgr->skipPastSpaces();
    12021200                }
    1203                  else if (fReaderMgr->skippedChar(chCloseParen))
     1201                else if (fReaderMgr->skippedChar(chCloseParen))
    12041202                {
    12051203                    //
     
    12221220                    break;
    12231221                }
    1224                  else if (fReaderMgr->skippedChar(opCh))
     1222                else if (fReaderMgr->skippedChar(opCh))
    12251223                {
    12261224                    // Check for a PE ref here, but don't require spaces
     
    12661264                        curNode = newCur;
    12671265                    }
    1268                      else
     1266                    else
    12691267                    {
    12701268                        //
     
    13321330                    }
    13331331                }
    1334                  else
     1332                else
    13351333                {
    13361334                    // Cannot be valid
     
    13641362
    13651363        // prepare for recursion
    1366         if(arrNestedDecl==NULL)
     1364        if (!arrNestedDecl)
     1365        {
    13671366            break;
     1367        }
    13681368        else
    13691369        {
     
    13761376                fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
    13771377
    1378             if(arrNestedDecl->empty())
    1379             {
    1380                 delete arrNestedDecl;
    1381                 arrNestedDecl=NULL;
     1378            if (arrNestedDecl->empty())
     1379            {
     1380                arrNestedDecl = NULL;
    13821381            }
    13831382        }
     
    14421441            }
    14431442            // Its got to at least be a valid XML character
    1444             else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh)) {
     1443            else if (!isXMLChar(nextCh)) {
    14451444
    14461445                XMLCh tmpBuf[9];
     
    16391638void DTDScanner::scanElementDecl()
    16401639{
     1640    DEBUG_MESSAGE("scanElementDecl()")
     1641
    16411642    //
    16421643    //  Space is legal (required actually) here so check for a PE ref. If
     
    16491650    // Get a buffer for the element name and scan in the name
    16501651    XMLBufBid bbName(fBufMgr);
    1651     if (!fReaderMgr->getName(bbName.getBuffer()))
     1652
     1653    bool gotName = fReaderMgr->getName(bbName.getBuffer());
     1654    DEBUG_MESSAGE(bbName.getRawBuffer())
     1655
     1656    if (!gotName)
    16521657    {
    16531658        fScanner->emitError(XMLErrs::ExpectedElementName);
     
    16711676            {
    16721677                if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
     1678                {
    16731679                    fScanner->getValidator()->emitError(XMLValid::ElementAlreadyExists, bbName.getRawBuffer());
    1674 
    1675                 dummyDecl.fElementName = new QName(*decl->fElementName);
     1680                }
     1681                dummyDecl.setElementName(decl->getElementName());
    16761682                decl = &dummyDecl;
    16771683            }
    16781684            isIgnored = true;
    16791685        }
    1680          else
     1686        else
    16811687        {
    16821688            //
     
    17291735        if (fDocTypeHandler)
    17301736            fDocTypeHandler->elementDecl(*decl, isIgnored);
    1731 
    1732         dummyDecl.fElementName = 0;
    17331737    }
    17341738}
     
    17441748void DTDScanner::scanEntityDecl()
    17451749{
     1750    DEBUG_MESSAGE("scanEntityDecl()")
     1751
    17461752    //
    17471753    //  Space is required here, but we cannot check for a PE Ref since
     
    17631769    if (isPEDecl)
    17641770    {
    1765         if(!fReaderMgr->getCurrentReader()->isWhitespace(fReaderMgr->peekNextChar()))
     1771        if(!isWhitespace(fReaderMgr->peekNextChar()))
    17661772        {
    17671773            isPEDecl=false;
     
    22162222                    fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
    22172223            }
    2218              else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh))
     2224             else if (!isXMLChar(nextCh))
    22192225            {
    22202226                XMLCh tmpBuf[9];
     
    25362542
    25372543                }
    2538                 else if (fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
     2544                else if (isWhitespace(nextCh))
    25392545                {
    25402546                    //
     
    25972603                {
    25982604                    fReaderMgr->getNextChar();
    2599                     if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh))
     2605                    if (!isXMLChar(nextCh))
    26002606                    {
    26012607                        XMLCh tmpBuf[9];
     
    26272633        catch(const EndOfEntityException& toCatch)
    26282634        {
     2635            DEBUG_MESSAGE("catch(const EndOfEntityException&)")
     2636
    26292637            //
    26302638            //  If the external entity ended while we were in markup, then that's
     
    28832891
    28842892                // Its got to at least be a valid XML character
    2885                 else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh))
     2893                else if (!isXMLChar(nextCh))
    28862894                {
    28872895                    XMLCh tmpBuf[9];
     
    29722980            }
    29732981        }
    2974          else if (fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
     2982         else if (isWhitespace(nextCh))
    29752983        {
    29762984            //
     
    30473055void DTDScanner::scanMarkupDecl(const bool parseTextDecl)
    30483056{
     3057    DEBUG_MESSAGE("scanMarkupDecl(" << parseTextDecl << ')')
     3058
    30493059    //
    30503060    //  We only have two valid first characters here. One is a ! which opens
     
    30693079            }
    30703080        }
    3071          else if (fReaderMgr->skippedChar(chOpenSquare))
     3081        else if (fReaderMgr->skippedChar(chOpenSquare))
    30723082        {
    30733083            //
     
    31403150            }
    31413151        }
    3142          else if (fReaderMgr->skippedString(XMLUni::fgAttListString))
     3152        else if (fReaderMgr->skippedString(XMLUni::fgAttListString))
    31433153        {
    31443154            scanAttListDecl();
    31453155        }
    3146          else if (fReaderMgr->skippedString(XMLUni::fgElemString))
     3156        else if (fReaderMgr->skippedString(XMLUni::fgElemString))
    31473157        {
    31483158            scanElementDecl();
    31493159        }
    3150          else if (fReaderMgr->skippedString(XMLUni::fgEntityString))
     3160        else if (fReaderMgr->skippedString(XMLUni::fgEntityString))
    31513161        {
    31523162            scanEntityDecl();
    31533163        }
    3154          else if (fReaderMgr->skippedString(XMLUni::fgNotationString))
     3164        else if (fReaderMgr->skippedString(XMLUni::fgNotationString))
    31553165        {
    31563166            scanNotationDecl();
    31573167        }
    3158          else
     3168        else
    31593169        {
    31603170            fScanner->emitError(XMLErrs::ExpectedMarkupDecl);
     
    31623172        }
    31633173    }
    3164      else if (nextCh == chQuestion)
     3174    else if (nextCh == chQuestion)
    31653175    {
    31663176        // It could be a PI or the XML declaration. Check for Decl
     
    36223632                }
    36233633                // Its got to at least be a valid XML character
    3624                 else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh)) {
     3634                else if (!isXMLChar(nextCh)) {
    36253635
    36263636                    XMLCh tmpBuf[9];
  • icXML/icXML-devel/src/icxercesc/validators/DTD/DTDScanner.hpp

    r3104 r3150  
    172172    void scanTextDecl();
    173173    bool isReadingExternalEntity();
    174 
     174    bool isXMLChar(const XMLCh Char);
     175    bool isWhitespace(const XMLCh Char);
    175176
    176177    // -----------------------------------------------------------------------
     
    235236    XMLScanner*                     fScanner;
    236237    NameIdPool<DTDEntityDecl>*      fPEntityDeclPool;
    237     unsigned int                    fEmptyNamespaceId;
     238    const unsigned int              fEmptyNamespaceId;
    238239    XMLSize_t                       fDocTypeReaderId;
     240    bool                            fXMLVersion1_0;
    239241};
    240242
     
    265267//  Helper methods
    266268// -----------------------------------------------------------------------
    267 inline bool DTDScanner::isReadingExternalEntity() {
     269inline bool DTDScanner::isReadingExternalEntity()
     270{
    268271    return (fDocTypeReaderId != fReaderMgr->getCurrentReaderNum());
    269272}
    270273
     274inline bool DTDScanner::isXMLChar(const XMLCh Char)
     275{
     276    return XMLNameChar::isXMLChar(Char, fXMLVersion1_0, false);
     277}
     278
     279inline bool DTDScanner::isWhitespace(const XMLCh Char)
     280{
     281    // all legal CR,NEL,LS or {CR,LF} or {CR,NEL} would have been normalized within the XMLReader
     282    return XMLNameChar::isWhitespace(Char, true);
     283}
     284
     285
    271286XERCES_CPP_NAMESPACE_END
    272287
  • icXML/icXML-devel/src/icxercesc/validators/DTD/DTDValidator.cpp

    r3103 r3150  
    7777        //  to do to validate it.
    7878        //
    79         const DTDElementDecl::ModelTypes modelType = ((DTDElementDecl*) elemDecl)->getModelType();
    80 
    81 
    82     DEBUG_GRAMMAR_MESSAGE(" modelType=" << modelType);
     79    const DTDElementDecl::ModelTypes modelType = ((DTDElementDecl*)elemDecl)->getModelType();
    8380
    8481        if (modelType == DTDElementDecl::Empty)
    8582        {
     83        DEBUG_GRAMMAR_MESSAGE("DTDElementDecl::Empty");
    8684                //
    8785                //  We can do this one here. It cannot have any children. If it does
     
    102100        else if ((modelType == DTDElementDecl::Mixed_Simple) || (modelType == DTDElementDecl::Children))
    103101        {
     102        DEBUG_GRAMMAR_MESSAGE("DTDElementDecl::Mixed_Simple|Children");
     103
    104104                // Get the element's content model or fault it in
    105                 const XMLContentModel* elemCM = elemDecl->getContentModel();
     105        const XMLContentModel* elemCM = ((DTDElementDecl*)elemDecl)->getContentModel();
     106
     107        DEBUG_GRAMMAR_MESSAGE(" -- elemCM=" << elemCM)
    106108
    107109                // Ask it to validate and return its return
  • icXML/icXML-devel/src/icxercesc/validators/common/MixedContentModel.cpp

    r3104 r3150  
    3232#include <icxercesc/validators/common/Grammar.hpp>
    3333#include <icxercesc/validators/schema/SubstitutionGroupComparator.hpp>
     34#include <icxmlc/XMLConfig.hpp>
    3435
    3536XERCES_CPP_NAMESPACE_BEGIN
     
    5051{
    5152        //
    52         //  Create a vector of unsigned ints that will be filled in with the
    53         //  ids of the child nodes. It will be expanded as needed but we give
    54         //  it an initial capacity of 64 which should be more than enough for
    55         //  99% of the scenarios.
    56         //
    57         ValueVectorOf<QName*> children(64, fMemoryManager);
    58         ValueVectorOf<ContentSpecNode::NodeTypes> childTypes(64, fMemoryManager);
    59 
    60         //
    6153        //  Get the parent element's content spec. This is the head of the tree
    6254        //  of nodes that describes the content model. We will iterate this
     
    6759                ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_NoParentCSN, fMemoryManager);
    6860
     61    //
     62    //  Create a vector of unsigned ints that will be filled in with the
     63    //  ids of the child nodes. It will be expanded as needed but we give
     64    //  it an initial capacity of 64 which should be more than enough for
     65    //  99% of the scenarios.
     66    //
     67    ValueVectorOf<QName*> children(64, fMemoryManager);
     68    ValueVectorOf<ContentSpecNode::NodeTypes> childTypes(64, fMemoryManager);
     69
    6970        // And now call the private recursive method that iterates the tree
    7071        buildChildList(curNode, children, childTypes);
     
    7576        //
    7677        fCount = children.size();
    77         fChildren = (QName**) fMemoryManager->allocate(fCount * sizeof(QName*)); //new QName*[fCount];
    78         fChildTypes = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
    79         (
    80                 fCount * sizeof(ContentSpecNode::NodeTypes)
    81         ); //new ContentSpecNode::NodeTypes[fCount];
    82         for (XMLSize_t index = 0; index < fCount; index++) {
    83                 fChildren[index] = new (fMemoryManager) QName(*children.elementAt(index));
     78    fChildren = (QName**)fMemoryManager->allocate(fCount * sizeof(QName*));
     79    fChildTypes = (ContentSpecNode::NodeTypes*)fMemoryManager->allocate(fCount * sizeof(ContentSpecNode::NodeTypes));
     80    for (XMLSize_t index = 0; index < fCount; index++)
     81    {
     82        fChildren[index] = new QName(*children.elementAt(index));
    8483                fChildTypes[index] = childTypes.elementAt(index);
    8584        }
     
    8887MixedContentModel::~MixedContentModel()
    8988{
    90         for (XMLSize_t index = 0; index < fCount; index++) {
    91                 delete fChildren[index];
    92         }
    93         fMemoryManager->deallocate(fChildren); //delete [] fChildren;
    94         fMemoryManager->deallocate(fChildTypes); //delete [] fChildTypes;
     89    for (XMLSize_t index = 0; index < fCount; index++)
     90    {
     91        delete fChildren[index];
     92    }
     93    fMemoryManager->deallocate(fChildren);
     94    fMemoryManager->deallocate(fChildTypes);
    9595}
    9696
     
    463463
    464464        // And recurse according to the type of node
    465         if (((curType & 0x0f) == ContentSpecNode::Choice)
    466         ||  ((curType & 0x0f) == ContentSpecNode::Sequence))
     465    if (((curType & 0x0f) == ContentSpecNode::Choice) || ((curType & 0x0f) == ContentSpecNode::Sequence))
    467466        {
    468467                // Recurse on the left and right nodes
  • icXML/icXML-devel/src/icxercesc/validators/schema/GeneralAttributeCheck.cpp

    r2807 r3150  
    221221
    222222                // skip namespace declarations
    223                 if (XMLStringU::isXMLNS(attName)) continue;
     223        if (XMLStringU::isXMLNS(attName)) continue;
    224224
    225225                // Bypass attributes that start with xml
  • icXML/icXML-devel/src/icxercesc/validators/schema/XSDDOMParser.cpp

    r2807 r3150  
    342342
    343343    #ifdef __GNUC__
    344     #warning I believe that the "if (elemDecl.hasAttDefs()) { ... } " code shouldn't be needed; but my assumption needs testing.
     344    #warning "I believe that the 'if (elemDecl.hasAttDefs()) { ... }' code shouldn't be needed; but my assumption needs testing."
    345345    #endif
    346346
Note: See TracChangeset for help on using the changeset viewer.