Ignore:
Timestamp:
Nov 18, 2013, 5:34:18 AM (6 years ago)
Author:
cameron
Message:

Changes to icxercesc files

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

Legend:

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

    r2721 r3564  
    2828#include <xercesc/util/XMLUni.hpp>
    2929#include <xercesc/util/OutOfMemoryException.hpp>
     30#include <icxmlc/XMLNamespaceResolver.hpp>
    3031
    3132XERCES_CPP_NAMESPACE_BEGIN
     33
     34typedef JanitorMemFunCall<XMLAttDef>    CleanupType;
    3235
    3336// ---------------------------------------------------------------------------
     
    7477};
    7578
    76 
    77 
    7879// ---------------------------------------------------------------------------
    7980//  XMLAttDef: Public, static data members
    8081// ---------------------------------------------------------------------------
    8182const unsigned int XMLAttDef::fgInvalidAttrId = 0xFFFFFFFE;
    82 
    8383
    8484// ---------------------------------------------------------------------------
     
    112112}
    113113
    114 
    115114// ---------------------------------------------------------------------------
    116115//  XMLAttDef: Hidden constructors
    117116// ---------------------------------------------------------------------------
    118 XMLAttDef::XMLAttDef( const XMLAttDef::AttTypes    type
    119                     , const XMLAttDef::DefAttTypes defType
    120                     , MemoryManager* const         manager) :
    121 
    122     fDefaultType(defType)
    123     , fType(type)
    124     , fCreateReason(XMLAttDef::NoReason)
    125     , fExternalAttribute(false)
    126     , fId(XMLAttDef::fgInvalidAttrId)
    127     , fValue(0)
    128     , fEnumeration(0)
    129     , fLastOccurrence(0)
    130     , fMemoryManager(manager)
    131 {
    132 }
    133 
    134 typedef JanitorMemFunCall<XMLAttDef>    CleanupType;
    135 
    136 XMLAttDef::XMLAttDef( const XMLCh* const           attrValue
    137                     , const XMLAttDef::AttTypes    type
    138                     , const XMLAttDef::DefAttTypes defType
    139                     , const XMLCh* const           enumValues
    140                     , MemoryManager* const         manager) :
    141 
    142     fDefaultType(defType)
    143     , fType(type)
    144     , fCreateReason(XMLAttDef::NoReason)
    145     , fExternalAttribute(false)
    146     , fId(XMLAttDef::fgInvalidAttrId)
    147     , fValue(0)
    148     , fEnumeration(0)
    149     , fLastOccurrence(0)
    150     , fMemoryManager(manager)
     117XMLAttDef::XMLAttDef(XMLStringPool* const qNameManager)
     118: fAttName(qNameManager)
     119, fDefaultType(Implied)
     120, fType(CData)
     121, fCreateReason(XMLAttDef::NoReason)
     122, fExternalAttribute(false)
     123, fId(XMLAttDef::fgInvalidAttrId)
     124, fValue(0)
     125, fEnumeration(0)
     126, fLastOccurrence(0)
     127{
     128
     129}
     130
     131XMLAttDef::XMLAttDef
     132(
     133    QName *                        attName
     134    , const XMLAttDef::AttTypes    type
     135    , const XMLAttDef::DefAttTypes defType
     136)
     137: fAttName(*attName)
     138, fDefaultType(defType)
     139, fType(type)
     140, fCreateReason(XMLAttDef::NoReason)
     141, fExternalAttribute(false)
     142, fId(XMLAttDef::fgInvalidAttrId)
     143, fValue(0)
     144, fEnumeration(0)
     145, fLastOccurrence(0)
     146{
     147
     148}
     149
     150XMLAttDef::XMLAttDef(const XMLAttDef & other)
     151: fAttName(*(other.getAttName()))
     152, fDefaultType(other.getDefaultType())
     153, fType(other.getType())
     154, fCreateReason(other.getCreateReason())
     155, fExternalAttribute(other.isExternal())
     156, fId(other.getId())
     157, fValue(0)
     158, fEnumeration(0)
     159, fLastOccurrence(other.getLastOccurrence())
    151160{
    152161    CleanupType cleanup(this, &XMLAttDef::cleanUp);
     
    154163    try
    155164    {
    156         fValue = XMLString::replicate(attrValue, fMemoryManager);
    157         fEnumeration = XMLString::replicate(enumValues, fMemoryManager);
     165        fValue = XMLString::replicate(other.getValue(), getMemoryManager());
     166        fEnumeration = XMLString::replicate(other.getEnumeration(), getMemoryManager());
    158167    }
    159168    catch(const OutOfMemoryException&)
    160169    {
    161170        cleanup.release();
    162 
    163171        throw;
    164172    }
     
    168176
    169177
     178XMLAttDef::XMLAttDef
     179(
     180      const XMLCh* const           prefix
     181    , const XMLCh* const           localPart
     182    , const int                    uriId
     183    , const XMLAttDef::AttTypes    type
     184    , const XMLAttDef::DefAttTypes defType
     185    , XMLStringPool* const         qNameManager
     186)
     187: fAttName(prefix, localPart, uriId, qNameManager)
     188, fDefaultType(defType)
     189, fType(type)
     190, fCreateReason(XMLAttDef::NoReason)
     191, fExternalAttribute(false)
     192, fId(XMLAttDef::fgInvalidAttrId)
     193, fValue(0)
     194, fEnumeration(0)
     195, fLastOccurrence(0)
     196{
     197
     198}
     199
     200XMLAttDef::XMLAttDef
     201(
     202    const   XMLCh* const           attName
     203    , const XMLAttDef::AttTypes    type
     204    , const XMLAttDef::DefAttTypes defType
     205    , XMLStringPool* const         qNameManager
     206)
     207: fAttName(attName, XMLNamespaceResolver::fEmptyUriId, qNameManager)
     208, fDefaultType(defType)
     209, fType(type)
     210, fCreateReason(XMLAttDef::NoReason)
     211, fExternalAttribute(false)
     212, fId(XMLAttDef::fgInvalidAttrId)
     213, fValue(0)
     214, fEnumeration(0)
     215, fLastOccurrence(0)
     216{
     217
     218}
     219
     220XMLAttDef::XMLAttDef
     221(
     222      const XMLCh* const           prefix
     223    , const XMLCh* const           localPart
     224    , const int                    uriId
     225    , const XMLCh* const           attrValue
     226    , const XMLAttDef::AttTypes    type
     227    , const XMLAttDef::DefAttTypes defType
     228    , const XMLCh* const           enumValues
     229    , XMLStringPool* const         qNameManager
     230)
     231: fAttName(prefix, localPart, uriId, qNameManager)
     232, fDefaultType(defType)
     233, fType(type)
     234, fCreateReason(XMLAttDef::NoReason)
     235, fExternalAttribute(false)
     236, fId(XMLAttDef::fgInvalidAttrId)
     237, fValue(0)
     238, fEnumeration(0)
     239, fLastOccurrence(0)
     240{
     241    CleanupType cleanup(this, &XMLAttDef::cleanUp);
     242
     243    try
     244    {
     245        fValue = XMLString::replicate(attrValue, getMemoryManager());
     246        fEnumeration = XMLString::replicate(enumValues, getMemoryManager());
     247    }
     248    catch(const OutOfMemoryException&)
     249    {
     250        cleanup.release();
     251
     252        throw;
     253    }
     254
     255    cleanup.release();
     256}
     257
     258
     259XMLAttDef::XMLAttDef
     260(
     261    const   XMLCh* const           attName
     262    , const XMLCh* const           attrValue
     263    , const XMLAttDef::AttTypes    type
     264    , const XMLAttDef::DefAttTypes defType
     265    , const XMLCh* const           enumValues
     266    , XMLStringPool* const         qNameManager
     267)
     268: fAttName(attName, XMLNamespaceResolver::fEmptyUriId, qNameManager)
     269, fDefaultType(defType)
     270, fType(type)
     271, fCreateReason(XMLAttDef::NoReason)
     272, fExternalAttribute(false)
     273, fId(XMLAttDef::fgInvalidAttrId)
     274, fValue(0)
     275, fEnumeration(0)
     276, fLastOccurrence(0)
     277{
     278    CleanupType cleanup(this, &XMLAttDef::cleanUp);
     279
     280    try
     281    {
     282        fValue = XMLString::replicate(attrValue, getMemoryManager());
     283        fEnumeration = XMLString::replicate(enumValues, getMemoryManager());
     284    }
     285    catch(const OutOfMemoryException&)
     286    {
     287        cleanup.release();
     288        throw;
     289    }
     290
     291    cleanup.release();
     292}
     293
    170294// ---------------------------------------------------------------------------
    171295//  XMLAttDef: Private helper methods
     
    174298{
    175299    if (fEnumeration)
    176         fMemoryManager->deallocate(fEnumeration);
     300        getMemoryManager()->deallocate(fEnumeration);
    177301
    178302    if (fValue)
    179         fMemoryManager->deallocate(fValue);
     303        getMemoryManager()->deallocate(fValue);
    180304}
    181305
     
    186310IMPL_XSERIALIZABLE_NOCREATE(XMLAttDef)
    187311
    188 void XMLAttDef::serialize(XSerializeEngine& serEng)
    189 {
    190 
    191     if (serEng.isStoring())
    192     {
    193         serEng<<(int)fDefaultType;
    194         serEng<<(int)fType;
    195         serEng<<(int)fCreateReason;
    196         serEng<<fExternalAttribute;
    197         serEng.writeSize (fId);
    198 
    199         serEng.writeString(fValue);
    200         serEng.writeString(fEnumeration);
    201     }
    202     else
    203     {
    204         int i;
    205         serEng>>i;
    206         fDefaultType = (DefAttTypes) i;
    207 
    208         serEng>>i;
    209         fType = (AttTypes)i;
    210 
    211         serEng>>i;
    212         fCreateReason = (CreateReasons)i;
    213 
    214         serEng>>fExternalAttribute;
    215         serEng.readSize (fId);
    216 
    217         serEng.readString(fValue);
    218         serEng.readString(fEnumeration);
    219     }
    220 }
     312void XMLAttDef::serialize(XSerializeEngine&)
     313{
     314    DEPRECATED_FEATURE_IN_ICXML;
     315}
     316
     317XMLAttDef::XMLAttDef(const XMLAttDef::AttTypes, const XMLAttDef::DefAttTypes, MemoryManager* const)
     318{
     319    DEPRECATED_FEATURE_IN_ICXML;
     320}
     321
     322XMLAttDef::XMLAttDef(const XMLCh* const, const XMLAttDef::AttTypes, const XMLAttDef::DefAttTypes, const XMLCh* const, MemoryManager* const)
     323{
     324    DEPRECATED_FEATURE_IN_ICXML;
     325}
     326
    221327
    222328XERCES_CPP_NAMESPACE_END
  • icXML/icXML-devel/src/icxercesc/framework/XMLAttDef.hpp

    r3150 r3564  
    1717#include <icxercesc/util/XMLString.hpp>
    1818#include <xercesc/util/XMemory.hpp>
     19#include <icxercesc/util/QName.hpp>
    1920#include <xercesc/internal/XSerializable.hpp>
    2021#include <icxmlc/XMLConfig.hpp>
     
    2324
    2425class XMLAttr;
    25 class QName;
    2626
    2727/** Represents the core information of an attribute definition
     
    383383        //  Hidden constructors
    384384        // -----------------------------------------------------------------------
    385         XMLAttDef
    386         (
    387                 const   AttTypes       type = CData
    388                 , const DefAttTypes    defType= Implied
    389                 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    390         );
    391         XMLAttDef
    392         (
    393                 const   XMLCh* const        attValue
    394                 , const AttTypes            type
    395                 , const DefAttTypes         defType
    396                 , const XMLCh* const        enumValues = 0
    397                 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    398         );
     385    XMLAttDef(XMLStringPool* const     qNameManager);
     386
     387    XMLAttDef(const XMLAttDef &        other);
     388
     389    XMLAttDef
     390    (
     391        QName *                        attName
     392        , const XMLAttDef::AttTypes    type
     393        , const XMLAttDef::DefAttTypes defType
     394    );
     395
     396    XMLAttDef
     397    (
     398          const XMLCh* const           prefix
     399        , const XMLCh* const           localPart
     400        , const int                    uriId
     401        , const XMLAttDef::AttTypes    type
     402        , const XMLAttDef::DefAttTypes defType
     403        , XMLStringPool* const         qNameManager
     404    );
     405
     406    XMLAttDef
     407    (
     408          const XMLCh* const           prefix
     409        , const XMLCh* const           localPart
     410        , const int                    uriId
     411        , const XMLCh* const           attValue
     412        , const XMLAttDef::AttTypes    type
     413        , const XMLAttDef::DefAttTypes defType
     414        , const XMLCh* const           enumValues
     415        , XMLStringPool* const         qNameManager
     416    );
     417
     418    XMLAttDef
     419    (
     420        const   XMLCh* const           attName
     421        , const XMLAttDef::AttTypes    type
     422        , const XMLAttDef::DefAttTypes defType
     423        , XMLStringPool* const         qNameManager
     424    );
     425
     426    XMLAttDef
     427    (
     428        const   XMLCh* const           attName
     429        , const XMLCh* const           attValue
     430        , const XMLAttDef::AttTypes    type
     431        , const XMLAttDef::DefAttTypes defType
     432        , const XMLCh* const           enumValues
     433        , XMLStringPool* const         qNameManager
     434    );
     435
     436    // -----------------------------------------------------------------------
     437    //  Deprecated constructors
     438    // -----------------------------------------------------------------------
     439    XMLAttDef
     440    (
     441        const   AttTypes       type = CData
     442        , const DefAttTypes    defType= Implied
     443        , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
     444    );
     445
     446    XMLAttDef
     447    (
     448        const   XMLCh* const        attValue
     449        , const AttTypes            type
     450        , const DefAttTypes         defType
     451        , const XMLCh* const        enumValues = 0
     452        , MemoryManager* const      manager = XMLPlatformUtils::fgMemoryManager
     453    );
    399454
    400455
     
    403458        //  Unimplemented constructors and operators
    404459        // -----------------------------------------------------------------------
    405         XMLAttDef(const XMLAttDef&);
    406460        XMLAttDef& operator=(const XMLAttDef&);
    407461
     
    416470        //  Private data members
    417471        //
     472    //  fAttName
     473    //      This is the name of the attribute.
     474    //
    418475        //  fDefaultType
    419476        //      Indicates what, if any, default stuff this attribute has.
     
    443500        //      This flag indicates whether or not the attribute was declared externally.
    444501        // -----------------------------------------------------------------------
    445         DefAttTypes     fDefaultType;
    446         AttTypes        fType;
    447         CreateReasons   fCreateReason;
    448         bool            fExternalAttribute;
    449         XMLSize_t       fId;
    450         XMLCh*          fValue;
    451         XMLCh*          fEnumeration;
    452         unsigned int    fLastOccurrence;
    453         MemoryManager*  fMemoryManager;
     502    QName               fAttName;
     503    DefAttTypes         fDefaultType;
     504    AttTypes            fType;
     505    CreateReasons       fCreateReason;
     506    bool                fExternalAttribute;
     507    XMLSize_t           fId;
     508    XMLCh*              fValue;
     509    XMLCh*              fEnumeration;
     510    unsigned int        fLastOccurrence;
    454511};
    455512
     
    495552inline MemoryManager* XMLAttDef::getMemoryManager() const
    496553{
    497         return fMemoryManager;
     554    return fAttName.getMemoryManager();
    498555}
    499556
     
    518575{
    519576        if (fEnumeration)
    520                 fMemoryManager->deallocate(fEnumeration);
    521 
    522         fEnumeration = XMLString::replicate(newValue, fMemoryManager);
     577        getMemoryManager()->deallocate(fEnumeration);
     578    fEnumeration = XMLString::replicate(newValue, getMemoryManager());
    523579}
    524580
     
    536592{
    537593        if (fValue)
    538            fMemoryManager->deallocate(fValue);
    539 
    540         fValue = XMLString::replicate(newValue, fMemoryManager);
     594       getMemoryManager()->deallocate(fValue);
     595    fValue = XMLString::replicate(newValue, getMemoryManager());
    541596}
    542597
  • icXML/icXML-devel/src/icxercesc/framework/XMLAttr.cpp

    r3103 r3564  
    3636//  XMLAttr: Constructors and Destructor
    3737// ---------------------------------------------------------------------------
    38 XMLAttr::XMLAttr(MemoryManager* const manager) :
    39 
    40           fSpecified(false)
    41         , fType(XMLAttDef::CData)
    42         , fValueLen(0)
    43         , fValue(0)
    44         , fAttName(0)
    45         , fMemoryManager(manager)
     38XMLAttr::XMLAttr(MemoryManager* const /* manager */)
     39: fSpecified(false)
     40, fType(XMLAttDef::CData)
     41, fValueLen(0)
     42, fValue(0)
     43, fAttName(0)
    4644{
    4745
    4846}
    4947
    50 XMLAttr::XMLAttr(   const   unsigned int        uriId
    51                                         , const XMLCh* const        attrName
    52                                         , const XMLCh* const        attrPrefix
    53                                         , const XMLCh* const        attrValue
    54                                         , const XMLAttDef::AttTypes type
    55                                         , const bool                specified
    56                                         , MemoryManager* const      manager
    57                                         , DatatypeValidator*
    58                                         , const bool /*isSchema*/ ):
    59 
    60           fSpecified(specified)
    61         , fType(type)
    62         , fValueLen(0)
    63         , fValue(0)
    64         , fAttName(0)
    65         , fMemoryManager(manager)
    66 {
    67         DEPRECATED_FEATURE_IN_ICXML;
    68 }
    69 
    70 XMLAttr::XMLAttr(   const   unsigned int        uriId
    71                                         , const XMLCh* const        rawName
    72                                         , const XMLCh* const        attrValue
    73                                         , const XMLAttDef::AttTypes type
    74                                         , const bool                specified
    75                                         , MemoryManager* const      manager
    76                                         , DatatypeValidator *
    77                                         , const bool /*isSchema*/ ):
    78 
    79           fSpecified(specified)
    80         , fType(type)
    81         , fValueLen(0)
    82         , fValue(0)
    83         , fAttName(0)
    84         , fMemoryManager(manager)
    85 {
    86         DEPRECATED_FEATURE_IN_ICXML;
    87 }
    88 
    89 XMLAttr::XMLAttr( const QName               *       qName
    90                                 , const XMLCh               * const attrValue
    91                                 , const XMLAttDef::AttTypes         type
    92                                 , const bool                        specified
    93                                 , MemoryManager             * const manager
    94                                 , DatatypeValidator         *       datatypeValidator
    95                                 , const bool                        isSchema )
    96         : fSpecified(specified)
    97         , fType(type)
    98         , fValueLen(0)
    99         , fValue(0)
    100         , fAttName(const_cast<QName*>(qName))
    101         , fMemoryManager(manager)
     48XMLAttr::XMLAttr
     49(
     50    const QName               *         qName
     51    , const XMLCh               * const attrValue
     52    , const XMLAttDef::AttTypes         type
     53    , const bool                        specified
     54    , MemoryManager             * const /* manager */
     55    , DatatypeValidator         *       datatypeValidator
     56    , const bool                        isSchema
     57)
     58: fSpecified(specified)
     59, fType(type)
     60, fValueLen(0)
     61, fValue(0)
     62, fAttName(const_cast<QName*>(qName))
    10263{
    10364        setValue(attrValue);
    10465}
    10566
    106 XMLAttr::XMLAttr( const QName               *       qName
    107                 , const XMLCh               * const attrValue
    108                 , const XMLSize_t                   attrLength
    109                 , const XMLAttDef::AttTypes         type
    110                 , const bool                        specified
    111                 , MemoryManager             * const manager
    112                 , DatatypeValidator         *       datatypeValidator
    113                 , const bool                        isSchema )
    114     : fSpecified(specified)
    115     , fType(type)
    116     , fValueLen(0)
    117     , fValue(0)
    118     , fAttName(const_cast<QName*>(qName))
    119     , fMemoryManager(manager)
     67XMLAttr::XMLAttr
     68(
     69    const QName               *         qName
     70    , const XMLCh               * const attrValue
     71    , const XMLSize_t                   attrLength
     72    , const XMLAttDef::AttTypes         type
     73    , const bool                        specified
     74    , MemoryManager             * const /* manager */
     75    , DatatypeValidator         *       datatypeValidator
     76    , const bool                        isSchema
     77)
     78: fSpecified(specified)
     79, fType(type)
     80, fValueLen(0)
     81, fValue(0)
     82, fAttName(const_cast<QName*>(qName))
    12083{
    12184    setValue(attrValue, attrLength);
     
    13295bool XMLAttr::isXMLNS() const
    13396{
    134     // (getURIId() == XMLNamespaceResolver::fEmptyUriId && XMLStringU::isXML(getQName(), XMLString::stringLen(getQName()))) ||
    13597    return (getURIId() == XMLNamespaceResolver::fXMLNSUriId);
    13698}
     
    139101//  XMLAttr: Setter methods
    140102// ---------------------------------------------------------------------------
    141 void XMLAttr::setName( const unsigned int    uriId
    142                                          , const XMLCh* const    attrName
    143                                          , const XMLCh* const    attrPrefix)
    144 {
    145         DEPRECATED_FEATURE_IN_ICXML;
    146 }
    147 
    148 
    149103void XMLAttr::setURIId(const unsigned int uriId)
    150104{
     
    173127}
    174128
     129void XMLAttr::setName(const unsigned int, const XMLCh* const, const XMLCh* const)
     130{
     131    DEPRECATED_FEATURE_IN_ICXML;
     132}
     133
     134XMLAttr::XMLAttr(const unsigned int, const XMLCh* const, const XMLCh* const, const XMLCh* const, const XMLAttDef::AttTypes, const bool, MemoryManager* const, DatatypeValidator*, const bool)
     135{
     136    DEPRECATED_FEATURE_IN_ICXML;
     137}
     138
     139XMLAttr::XMLAttr(const unsigned int, const XMLCh* const, const XMLCh* const, const XMLAttDef::AttTypes, const bool, MemoryManager* const, DatatypeValidator *, const bool )
     140{
     141    DEPRECATED_FEATURE_IN_ICXML;
     142}
     143
     144
    175145XERCES_CPP_NAMESPACE_END
  • icXML/icXML-devel/src/icxercesc/framework/XMLAttr.hpp

    r2774 r3564  
    2222XERCES_CPP_NAMESPACE_BEGIN
    2323
    24 class XMLScanner;
    25 class IGXMLScanner;
    26 class DOMXPathExpressionImpl;
     24class XMLStringPool;
    2725
    2826/**
     
    6765          * @param  manager     The configurable memory manager
    6866          */
    69         XMLAttr(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     67    XMLAttr(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
    7068
    7169        /**
     
    7371          * required to construct a complete attribute object.
    7472          *
    75           * @param  uriId       The id into the validator's URI pool of the URI
    76           *                     that the prefix mapped to. Only used if namespaces
    77           *                     are enabled/supported.
    78           *
    79           * @param  attrName    The base name of the attribute, i.e. the part
    80           *                     after any prefix.
    81           *
    82           * @param  attrPrefix  The prefix, if any, of this attribute's name. If
    83           *                     this is empty, then uriID is meaningless as well.
     73          * @param  qName       The precomputed qName that is stored in the symbol table
    8474          *
    8575          * @param  attrValue   The value string of the attribute, which should
     
    10393        XMLAttr
    10494        (
    105                   const unsigned int        uriId
    106                 , const XMLCh* const        attrName
    107                 , const XMLCh* const        attrPrefix
    108                 , const XMLCh* const        attrValue
     95        const QName *               qName
     96        , const XMLCh* const        attrValue
    10997                , const XMLAttDef::AttTypes type = XMLAttDef::CData
    11098                , const bool                specified = true
    11199                , MemoryManager* const      manager = XMLPlatformUtils::fgMemoryManager
    112                 , DatatypeValidator * datatypeValidator = 0
    113                 , const bool isSchema = false
    114         );
    115 
    116         /**
    117           * This is the primary constructor which takes all of the information
    118           * required to construct a complete attribute object.
    119           *
    120           * @param  uriId       The id into the validator's URI pool of the URI
    121           *                     that the prefix mapped to. Only used if namespaces
    122           *                     are enabled/supported.
    123           *
    124           * @param  rawName     The raw name of the attribute.
    125           *
    126           * @param  attrValue   The value string of the attribute, which should
    127           *                     be fully normalized by XML rules!
    128           *
    129           * @param  type        The type of the attribute. This will indicate
    130           *                     the type of normalization done and constrains
    131           *                     the value content. Make sure that the value
    132           *                     set meets the constraints!
    133           *
    134           * @param  specified   Indicates whether the attribute was explicitly
    135           *                     specified or not. If not, then it was faulted
    136           *                     in from a FIXED or DEFAULT value.
    137           *
    138           * @param  manager     The configurable memory manager
    139           * @param datatypeValidator type used to validate the attribute,
    140           *                         if it was validated by an XML Schema
    141           * @param isSchema         true if and only if this attribute was validated
    142           *                         by an XML Schema
    143           */
    144         XMLAttr
    145         (
    146                 const unsigned int uriId
    147                 , const XMLCh* const rawName
    148                 , const XMLCh* const attrValue
    149                 , const XMLAttDef::AttTypes type = XMLAttDef::CData
    150                 , const bool specified = true
    151                 , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
    152                 , DatatypeValidator * datatypeValidator = 0
    153                 , const bool isSchema = false
    154         );
    155 
    156 
    157         /**
    158           * This is the primary constructor which takes all of the information
    159           * required to construct a complete attribute object.
    160           *
    161           * @param  qName       The precomputed qName that is stored in the symbol table
    162           *
    163           * @param  attrValue   The value string of the attribute, which should
    164           *                     be fully normalized by XML rules!
    165           *
    166           * @param  type        The type of the attribute. This will indicate
    167           *                     the type of normalization done and constrains
    168           *                     the value content. Make sure that the value
    169           *                     set meets the constraints!
    170           *
    171           * @param  specified   Indicates whether the attribute was explicitly
    172           *                     specified or not. If not, then it was faulted
    173           *                     in from a FIXED or DEFAULT value.
    174           *
    175           * @param  manager     The configurable memory manager
    176           * @param datatypeValidator type used to validate the attribute,
    177           *                         if it was validated by an XML Schema
    178           * @param isSchema         true if and only if this attribute was validated
    179           *                         by an XML Schema
    180           */
    181         XMLAttr
    182         (
    183                 const QName * qName
    184                 , const XMLCh* const attrValue
    185                 , const XMLAttDef::AttTypes type = XMLAttDef::CData
    186                 , const bool                specified = true
    187                 , MemoryManager* const      manager = XMLPlatformUtils::fgMemoryManager
    188                 , DatatypeValidator * datatypeValidator = 0
    189                 , const bool isSchema = false
     100        , DatatypeValidator *       datatypeValidator = 0
     101        , const bool                isSchema = false
    190102        );
    191103
     
    237149
    238150
     151    // -----------------------------------------------------------------------
     152    //  Deprecated Constructors
     153    // -----------------------------------------------------------------------
     154
     155    XMLAttr
     156    (
     157          const unsigned int        uriId
     158        , const XMLCh* const        attrName
     159        , const XMLCh* const        attrPrefix
     160        , const XMLCh* const        attrValue
     161        , const XMLAttDef::AttTypes type = XMLAttDef::CData
     162        , const bool                specified = true
     163        , MemoryManager* const      manager = XMLPlatformUtils::fgMemoryManager
     164        , DatatypeValidator *       datatypeValidator = 0
     165        , const bool                isSchema = false
     166    );
     167
     168    XMLAttr
     169    (
     170        const unsigned int          uriId
     171        , const XMLCh* const        rawName
     172        , const XMLCh* const        attrValue
     173        , const XMLAttDef::AttTypes type = XMLAttDef::CData
     174        , const bool                specified = true
     175        , MemoryManager* const      manager = XMLPlatformUtils::fgMemoryManager
     176        , DatatypeValidator *       datatypeValidator = 0
     177        , const bool                isSchema = false
     178    );
     179
    239180        // -----------------------------------------------------------------------
    240181        //  Getter methods
     
    497438          */
    498439        void setValue(const XMLCh* const newValue, const XMLSize_t length);
    499 
    500 #if 0
    501         /**
    502           * This method will update the value field of the attribute.
    503           *
    504           * @param  newValue    The value string of the attribute, which should
    505           *                     be fully normalized by XML rules according to the
    506           *                     attribute type.
    507           */
    508         void setValue(const XMLBuffer & newValue);
    509 #endif
    510440
    511441        /**
     
    567497        const XMLCh*        fValue;
    568498        QName*              fAttName;
    569         MemoryManager*      fMemoryManager;
    570499};
    571500
  • icXML/icXML-devel/src/icxercesc/framework/XMLDocumentHandler.hpp

    r3157 r3564  
    3232class XMLEntityDecl;
    3333class ContentHandler;
     34class XMLDocumentDisseminator;
    3435
    3536/**
     
    4142  * has some extra methods required to get all the data out.
    4243  */
     44
     45/**
     46TODO: the document handler should include a factory method to produce an templated XMLDocumentDesseminator for the
     47XMLParser class. This would improve performance without substantially increasing the size of the compiled library.
     48However, such a change would completely invalidate any user made document handlers. Is this a realistic concern?
     49**/
     50
    4351class XMLPARSER_EXPORT XMLDocumentHandler
    4452{
    4553    friend class XMLDocumentDisseminator;
     54    template <class ScannerType> friend class XMLParserImpl;
     55    template <class DocHandlerType, bool doPSVI> friend class XMLDocumentDisseminatorImpl;
    4656
    4757public:
     
    261271        ) = 0;
    262272
     273protected:
     274
     275    /** Called by the XMLParserImpl. This is a factory method to provide it with a templated version
     276      * of the XMLDocumentDisseminator; each of which is optimized for SAX, SAX2 or DOM, depending
     277      * on the parser being used.
     278      *
     279      * @param  parser          pointer to the actual parser impl
     280      */
     281    virtual XMLDocumentDisseminator * createDocumentDisseminator() = 0;
     282
    263283        //@}
    264 protected :
    265         // -----------------------------------------------------------------------
     284
     285    // -----------------------------------------------------------------------
    266286        //  Hidden Constructors
    267287        // -----------------------------------------------------------------------
  • icXML/icXML-devel/src/icxercesc/framework/XMLElementDecl.cpp

    r3157 r3564  
    6060XMLElementDecl::setElementName(const XMLCh* const prefix, const XMLCh* const localPart, const int uriId )
    6161{
    62     cleanUp();
    63         fElementName = new (fMemoryManager) QName(prefix, localPart, uriId, fMemoryManager);
    64         fUriId = uriId;
     62    fElementName->setName(prefix, localPart, uriId);
    6563}
    6664
     
    6866XMLElementDecl::setElementName(const XMLCh* const rawName, const int uriId)
    6967{
    70     cleanUp();
    71         fElementName = new (fMemoryManager) QName(rawName, uriId, fMemoryManager);
    72         fUriId = uriId;
     68    fElementName->setName(rawName, uriId);
    7369}
    7470
    7571void XMLElementDecl::setElementName(const QName* const elementName)
    7672{
    77     cleanUp();
    78     fElementName = new QName(*elementName);
    79         fUriId = elementName->getURI();
     73    *fElementName = *elementName;
    8074}
    8175
     
    8377//  ElementDecl: Hidden constructors
    8478// ---------------------------------------------------------------------------
    85 XMLElementDecl::XMLElementDecl(MemoryManager* const manager) :
    86 fMemoryManager(manager)
    87 , fElementName(0)
     79XMLElementDecl::XMLElementDecl(XMLStringPool * const stringManager)
     80: fElementName(new (stringManager->getMemoryManager()) QName(stringManager))
    8881, fCreateReason(XMLElementDecl::NoReason)
    8982, fId(XMLElementDecl::fgInvalidElemId)
    90 , fUriId(0)
    91 , fNamespaceContextId(0)
    9283, fExternalElement(false)
    9384{
    9485
    9586}
     87
     88XMLElementDecl::XMLElementDecl(const QName & qName)
     89: fElementName(new (qName.getMemoryManager()) QName(qName))
     90, fCreateReason(XMLElementDecl::NoReason)
     91, fId(XMLElementDecl::fgInvalidElemId)
     92, fExternalElement(false)
     93{
     94
     95}
     96
     97
    9698
    9799/***
     
    117119}
    118120
     121XMLElementDecl::XMLElementDecl(MemoryManager* const)
     122{
     123    DEPRECATED_FEATURE_IN_ICXML;
     124}
     125
    119126XERCES_CPP_NAMESPACE_END
  • icXML/icXML-devel/src/icxercesc/framework/XMLElementDecl.hpp

    r3157 r3564  
    5555class XMLPARSER_EXPORT XMLElementDecl : public XSerializable, public XMemory
    5656{
    57     friend class XMLDocumentDisseminator;
     57    friend class XMLDocumentDisseminator;   
     58    template <bool doPSVI> friend class SAX2DocumentDisseminatorImpl;
     59    template <bool doPSVI> friend class SAXDocumentDisseminatorImpl;
     60    friend class XSDDOMDocumentDisseminatorImpl;
     61    template <class DocHandlerType, bool doPSVI> friend class XMLDocumentDisseminatorImpl;
     62    friend class XMLIdentityConstraintValidator;
     63
    5864    template<class XMLScannerType> friend class XMLGrammarValidator;
    5965    friend class DTDScanner;
    6066    friend class IGXMLScanner;
     67    friend class ContentSpecNode;
    6168
    6269public:
     
    406413        void setExternalElemDeclaration(const bool aValue);
    407414
    408 
    409     unsigned int getNamespaceContextId() const;
    410 
    411415        //@}
    412416
     
    442446protected :
    443447        // -----------------------------------------------------------------------
    444         //  Hidden constructors
    445         // -----------------------------------------------------------------------
    446         XMLElementDecl(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
     448    //  Hidden constructor
     449        // -----------------------------------------------------------------------
     450    XMLElementDecl(const QName & qName);
     451
     452    XMLElementDecl(XMLStringPool * const manager);
     453
     454    // -----------------------------------------------------------------------
     455    //  Deprecated constructor
     456    // -----------------------------------------------------------------------
     457    XMLElementDecl(MemoryManager* const manager);
     458
     459
     460    // -----------------------------------------------------------------------
     461    //  Setter methods
     462    // -----------------------------------------------------------------------
     463    void setURI(const unsigned int uriId);
     464
     465    inline XMLStringPool * getStringPool();
    447466
    448467private :
     
    479498        //      This flag indicates whether or the element was declared externally.
    480499        // -----------------------------------------------------------------------
    481         MemoryManager*      fMemoryManager;
    482         const QName *       fElementName;
     500    QName *             fElementName;
    483501        CreateReasons       fCreateReason;
    484502        XMLSize_t           fId;
    485         unsigned int            fUriId;
    486     unsigned int        fNamespaceContextId;
    487503        bool                fExternalElement;
    488504};
     
    493509inline const XMLCh* XMLElementDecl::getBaseName() const
    494510{
    495         return fElementName->getLocalPart();
     511    return fElementName->getLocalPart();
    496512}
    497513
    498514inline XMLCh* XMLElementDecl::getBaseName()
    499515{
    500         return const_cast<QName*>(fElementName)->getLocalPart();
     516    return fElementName->getLocalPart();
    501517}
    502518
    503519inline const XMLCh* XMLElementDecl::getLocalPart() const
    504520{
    505         return fElementName->getLocalPart();
     521    return fElementName->getLocalPart();
    506522}
    507523
    508524inline XMLCh* XMLElementDecl::getLocalPart()
    509525{
    510         return const_cast<QName*>(fElementName)->getLocalPart();
     526    return fElementName->getLocalPart();
    511527}
    512528
    513529inline unsigned int XMLElementDecl::getURI() const
    514530{
    515         return fUriId;
     531    return fElementName->getURI();
    516532}
    517533
    518534inline const QName* XMLElementDecl::getElementName() const
    519535{
    520         QName * elementName = const_cast<QName*>(fElementName);
    521         elementName->setURI(getURI());
    522         return elementName;
     536    return fElementName;
    523537}
    524538
    525539inline QName* XMLElementDecl::getElementName()
    526540{
    527         QName * elementName = const_cast<QName*>(fElementName);
    528         elementName->setURI(getURI());
    529         return elementName;
     541    return fElementName;
    530542}
    531543
    532544inline const XMLCh* XMLElementDecl::getFullName() const
    533545{
    534         return fElementName->getRawName();
     546    return fElementName->getRawName();
    535547}
    536548
    537549inline const XMLCh* XMLElementDecl::getRawName() const
    538550{
    539         return fElementName->getRawName();
     551    return fElementName->getRawName();
    540552}
    541553
     
    561573}
    562574
    563 inline unsigned int XMLElementDecl::getNamespaceContextId() const
    564 {
    565     return fNamespaceContextId;
    566 }
    567 
    568575inline MemoryManager* XMLElementDecl::getMemoryManager() const
    569576{
    570         return fMemoryManager;
     577    return fElementName->getMemoryManager();
     578}
     579
     580inline XMLStringPool * XMLElementDecl::getStringPool()
     581{
     582    return fElementName->fStringPool;
    571583}
    572584
     
    585597}
    586598
    587 
    588599inline void XMLElementDecl::setExternalElemDeclaration(const bool aValue)
    589600{
     
    591602}
    592603
     604inline void XMLElementDecl::setURI(const unsigned int uriId)
     605{
     606    fElementName->setURI(uriId);
     607}
     608
    593609inline void XMLElementDecl::cleanUp()
    594610{
    595     delete fElementName;
     611    delete fElementName; fElementName = 0;
    596612}
    597613
  • icXML/icXML-devel/src/icxercesc/framework/XMLEntityDecl.hpp

    r3104 r3564  
    193193
    194194    /**
     195      * Get the base line number of this entity. I.e., where it starts in the
     196      * file.
     197      */
     198    XMLFileLoc getBaseLine() const;
     199
     200    /**
     201      * Get the base column number of this entity. I.e., where it starts in the
     202      * file.
     203      */
     204    XMLFileLoc getBaseColumn() const;
     205
     206    /**
    195207      * Gets the base URI for this entity.
    196208      */
     
    280292
    281293    /**
    282      *  This method will set a new sysetm id on this entity. This will
     294     *  This method will set a new system id on this entity. This will
    283295     *  then control where the source for this entity lives. If it is
    284296     *  an internal entity, then the system id is only for bookkeeping
     
    289301     */
    290302    void setSystemId(const XMLCh* const newId);
     303
     304
     305    /**
     306      * set the base line number of this entity. I.e., where it starts in the
     307      * file.
     308      *
     309      * @param  baseLine     The new base line number to give to the entity.
     310      */
     311    void setBaseLine(const XMLFileLoc baseLine);
     312
     313    /**
     314      * set the column line number of this entity. I.e., where it starts in the
     315      * file.
     316      *
     317      * @param  baseLine     The new base column number to give to the entity.
     318      */
     319    void setBaseColumn(const XMLFileLoc baseColumn);
    291320
    292321    /**
     
    384413    XMLCh*          fPublicId;
    385414    XMLCh*          fSystemId;
    386     XMLCh*          fBaseURI;
     415    XMLFileLoc      fBaseLine;
     416    XMLFileLoc      fBaseColumn;
     417    XMLCh*          fBaseURI;   
    387418    bool            fIsExternal;
    388419    MemoryManager*  fMemoryManager;
     
    418449}
    419450
     451inline XMLFileLoc XMLEntityDecl::getBaseLine() const
     452{
     453    return fBaseLine;
     454}
     455
     456inline XMLFileLoc XMLEntityDecl::getBaseColumn() const
     457{
     458    return fBaseColumn;
     459}
     460
    420461inline const XMLCh* XMLEntityDecl::getBaseURI() const
    421462{
     
    494535}
    495536
     537inline void XMLEntityDecl::setBaseLine(const XMLFileLoc baseLine)
     538{
     539    fBaseLine = baseLine;
     540}
     541
     542inline void XMLEntityDecl::setBaseColumn(const XMLFileLoc baseColumn)
     543{
     544    fBaseColumn = baseColumn;
     545}
     546
    496547inline void XMLEntityDecl::setValue(const XMLCh* const newValue)
    497548{
  • icXML/icXML-devel/src/icxercesc/framework/XMLGrammarPool.hpp

    r2807 r3564  
    283283        ,fIgnoreSerializedAnnotations(false)
    284284        {
    285         };
     285    }
    286286        //@}
    287287
  • icXML/icXML-devel/src/icxercesc/framework/XMLGrammarPoolImpl.cpp

    r3103 r3564  
    3333#include <xercesc/util/OutOfMemoryException.hpp>
    3434#include <xercesc/util/SynchronizedStringPool.hpp>
     35#include <icxmlc/XMLSymbolTable.hpp>
    3536
    3637XERCES_CPP_NAMESPACE_BEGIN
     
    4041{
    4142        delete fXSModel;
    42         fXSModel = 0;
    4343        fXSModel = new (getMemoryManager()) XSModel(this, getMemoryManager());
    4444        fXSModelIsValid = true;
     
    5353,fStringPool(0)
    5454,fSynchronizedStringPool(0)
     55,fURIPool(0)
     56,fSynchronizedURIPool(0)
    5557,fXSModel(0)
    5658,fLocked(false)
    5759,fXSModelIsValid(false)
    5860{
     61    DEBUG_MESSAGE(" ******************  XMLGrammarPoolImpl() ******************* ")
     62
    5963        fGrammarRegistry = new (memMgr) RefHashTableOf<Grammar>(29, true, memMgr);
    60         fStringPool = new (memMgr) XMLStringPool(109, memMgr);
     64    DEBUG_MESSAGE(" -- constructing general string pool")
     65    fStringPool = new (memMgr) XMLStringPool(memMgr);
     66
     67    unsigned int xsiTypeId = fStringPool->addNewEntry(SchemaSymbols::fgXSI_TYPE);
     68    assert (xsiTypeId == XMLSymbolTable::Type);
     69    unsigned int xsiNilId = fStringPool->addNewEntry(SchemaSymbols::fgATT_NILL);
     70    assert (xsiNilId == XMLSymbolTable::Nil);
     71    unsigned int xsiSchemaLocationId = fStringPool->addNewEntry(SchemaSymbols::fgXSI_SCHEMALOCATION);
     72    assert (xsiSchemaLocationId == XMLSymbolTable::SchemaLocation);
     73    unsigned int xsiNoNamespaceSchemaLocationId = fStringPool->addNewEntry(SchemaSymbols::fgXSI_NONAMESPACESCHEMALOCATION);
     74    assert (xsiNoNamespaceSchemaLocationId == XMLSymbolTable::NoNamespaceSchemaLocation);
     75
     76    DEBUG_MESSAGE(" -- constructing URI string pool")
     77    fURIPool = new (memMgr) XMLStringPool(memMgr);
     78    unsigned int emptyUriId = fURIPool->addNewEntry(XMLUni::fgZeroLenString);
     79    assert (emptyUriId == (XMLNamespaceResolver::fEmptyUriId));
     80    unsigned int xmlUriId = fURIPool->addNewEntry(XMLUni::fgXMLURIName);
     81    assert (xmlUriId == (XMLNamespaceResolver::fXMLUriId));
     82    unsigned int xmlnsUriId = fURIPool->addNewEntry(XMLUni::fgXMLNSURIName);
     83    assert (xmlnsUriId == (XMLNamespaceResolver::fXMLNSUriId));
     84    unsigned int schemaInstanceUriId = fURIPool->addNewEntry(SchemaSymbols::fgURI_XSI);
     85    assert (schemaInstanceUriId == (XMLNamespaceResolver::fSchemaInstanceUriId));
    6186}
    6287
    6388XMLGrammarPoolImpl::~XMLGrammarPoolImpl()
    6489{
    65         delete fGrammarRegistry;
    66         delete fStringPool;
     90        delete fGrammarRegistry;       
    6791        delete fSynchronizedStringPool;
     92    delete fStringPool;
     93    delete fSynchronizedURIPool;
     94    delete fURIPool;
    6895        delete fXSModel;
    6996}
     
    148175                fLocked = true;
    149176                MemoryManager *memMgr = getMemoryManager();
    150                 if(!fSynchronizedStringPool)
     177        if (!fSynchronizedStringPool)
    151178                {
    152179                        fSynchronizedStringPool = new (memMgr) XMLSynchronizedStringPool(fStringPool, 109, memMgr);
     180            fSynchronizedURIPool = new (memMgr) XMLSynchronizedStringPool(fURIPool, 109, memMgr);
    153181                }
    154182                if (!fXSModelIsValid)
     
    167195                {
    168196                        fSynchronizedStringPool->flushAll();
     197            fSynchronizedURIPool->flushAll();
     198
    169199                        // if user calls Lock again, need to have null fSynchronizedStringPool
    170200                        delete fSynchronizedStringPool;
    171                         fSynchronizedStringPool = 0;
     201                        fSynchronizedStringPool = 0;                       
     202            delete fSynchronizedURIPool;
     203            fSynchronizedURIPool = 0;
    172204                }
    173205                fXSModelIsValid = false;
     
    190222SchemaGrammar* XMLGrammarPoolImpl::createSchemaGrammar()
    191223{
    192         return new (getMemoryManager()) SchemaGrammar(getMemoryManager());
     224    return new (getMemoryManager()) SchemaGrammar(fStringPool, getMemoryManager());
    193225}
    194226
     
    214246}
    215247
    216 XMLStringPool *XMLGrammarPoolImpl::getStringPool()
    217 {
    218         if (fLocked)
    219                 return fSynchronizedStringPool;
    220         return fStringPool;
     248XMLStringPool * XMLGrammarPoolImpl::getStringPool()
     249{
     250    return unlikely(fLocked) ? fSynchronizedStringPool : fStringPool;
     251}
     252
     253XMLStringPool *XMLGrammarPoolImpl::getURIStringPool()
     254{
     255    return unlikely(fLocked) ? fSynchronizedURIPool : fURIPool;
    221256}
    222257
     
    359394}
    360395
    361 // @@ DEPRECATED @@ this function is renamed to getStringPool to highlight the fact it is NOT a URI
    362 // string pool, but rather a general string pool.
    363 XMLStringPool *XMLGrammarPoolImpl::getURIStringPool()
    364 {
    365         DEPRECATED_FEATURE_IN_ICXML;
    366 }
    367 
    368396XERCES_CPP_NAMESPACE_END
  • icXML/icXML-devel/src/icxercesc/framework/XMLGrammarPoolImpl.hpp

    r2721 r3564  
    269269        XMLStringPool*                      fStringPool;
    270270        XMLSynchronizedStringPool*          fSynchronizedStringPool;
     271    XMLStringPool*                      fURIPool;
     272    XMLSynchronizedStringPool*          fSynchronizedURIPool;
    271273        XSModel*                            fXSModel;
    272274        bool                                fLocked;
  • icXML/icXML-devel/src/icxercesc/framework/XMLRecognizer.hpp

    r2721 r3564  
    141141bool
    142142XMLRecognizer::isSwapped(const XMLRecognizer::Encodings fEncoding)
    143 {
     143{   
    144144    if (XMLPlatformUtils::fgXMLChBigEndian)
    145145    {
  • icXML/icXML-devel/src/icxercesc/framework/XMLValidator.hpp

    r2721 r3564  
    2626#include <xercesc/framework/XMLValidityCodes.hpp>
    2727#include <icxmlc/XMLChildElement.hpp>
     28#include <xercesc/sax/Locator.hpp>
    2829#include <icxmlc/XMLConfig.hpp>
    2930
     
    3536class XMLScanner;
    3637class Grammar;
    37 
    3838
    3939/**
     
    288288                , XMLBufferMgr* const       bufMgr
    289289        );
     290
     291
     292
     293    void setLocator(Locator * const locator);
     294
    290295
    291296        /**
     
    332337         */
    333338        void emitError(const XMLValid::Codes toEmit);
     339
    334340        void emitError
    335341        (
     
    340346                , const XMLCh* const    text4 = 0
    341347        );
     348
    342349        void emitError
    343350        (
     
    348355                , const char* const     text4 = 0
    349356        );
     357
    350358        void emitError
    351359        (
     
    399407        XMLBufferMgr*       fBufMgr;
    400408        XMLErrorReporter*   fErrorReporter;
    401         ReaderMgr*          fReaderMgr;
     409    //ReaderMgr*          fReaderMgr;
     410    Locator*            fLocator;
    402411        XMLScanner*         fScanner;
    403412};
     
    414423        // We don't own any of these, we just reference them
    415424        fScanner = owningScanner;
    416         fReaderMgr = readerMgr;
     425    //fReaderMgr = readerMgr;
     426    setLocator(reinterpret_cast<Locator*>(readerMgr));
    417427        fBufMgr = bufMgr;
    418428}
     
    440450inline const ReaderMgr* XMLValidator::getReaderMgr() const
    441451{
    442         return fReaderMgr;
     452    //return fReaderMgr;
     453    DEPRECATED_FEATURE_IN_ICXML;
    443454}
    444455
    445456inline ReaderMgr* XMLValidator::getReaderMgr()
    446457{
    447         return fReaderMgr;
     458    //return fReaderMgr;
     459    DEPRECATED_FEATURE_IN_ICXML;
    448460}
    449461
     
    458470}
    459471
     472inline void XMLValidator::setLocator(Locator * const locator)
     473{
     474    fLocator = locator;
     475}
     476
    460477XERCES_CPP_NAMESPACE_END
    461478
  • icXML/icXML-devel/src/icxercesc/internal/DGXMLScanner.cpp

    r3158 r3564  
    5353//  DGXMLScanner: Constructors and Destructor
    5454// ---------------------------------------------------------------------------
    55 DGXMLScanner::DGXMLScanner(XMLValidator* const valToAdopt
    56                                                  , GrammarResolver* const grammarResolver
    57                                                  , MemoryManager* const manager) :
    58 
    59         XMLScanner(valToAdopt, grammarResolver, manager)
    60         , fAttrNSList(0)
    61         , fDTDValidator(0)
    62         , fDTDGrammar(0)
    63         , fDTDElemNonDeclPool(0)
    64         , fElemCount(0)
    65         , fAttDefRegistry(0)
    66         , fUndeclaredAttrRegistry(0)
    67 #ifdef MOVE_BUFFERS_OUT_OF_XMLSCANNER
    68         , fAttNameBuf(1023, manager)
    69         , fAttValueBuf(1023, manager)
    70         , fCDataBuf(1023, manager)
    71         , fQNameBuf(1023, manager)
    72         , fPrefixBuf(1023, manager)
    73         , fURIBuf(1023, manager)
    74         , fWSNormalizeBuf(1023, manager)
    75 #endif
     55DGXMLScanner::DGXMLScanner
     56(
     57    XMLValidator* const valToAdopt
     58    , GrammarResolver* const grammarResolver
     59    , MemoryManager* const manager
     60)
     61: XMLScanner(valToAdopt, grammarResolver, manager)
     62, fAttrNSList(0)
     63, fDTDValidator(0)
     64, fDTDGrammar(0)
     65, fDTDElemNonDeclPool(0)
     66, fElemCount(0)
     67, fAttDefRegistry(0)
     68, fUndeclaredAttrRegistry(0)
     69, fAttNameBuf(1023, manager)
     70, fAttValueBuf(1023, manager)
     71, fCDataBuf(1023, manager)
     72, fQNameBuf(1023, manager)
     73, fPrefixBuf(1023, manager)
     74, fURIBuf(1023, manager)
     75, fWSNormalizeBuf(1023, manager)
    7676{
    7777        CleanupType cleanup(this, &DGXMLScanner::cleanUp);
     
    22802280void DGXMLScanner::commonInit()
    22812281{
    2282 #ifdef DGXML_SCANNER_DEPRECATED
    22832282        DEPRECATED_FEATURE_IN_ICXML;
    2284 #else
    2285         //  And we need one for the raw attribute scan. This just stores key/
    2286         //  value string pairs (prior to any processing.)
    2287         fAttrNSList = new (fMemoryManager) ValueVectorOf<XMLAttr*>(8, fMemoryManager);
    2288 
    2289         //  Create the Validator and init them
    2290         fDTDValidator = new (fMemoryManager) DTDValidator();
    2291         initValidator(fDTDValidator);
    2292         fDTDElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29, 128, fMemoryManager);
    2293         fAttDefRegistry = new (fMemoryManager) RefHashTableOf<unsigned int, PtrHasher>
    2294         (
    2295                 131, false, fMemoryManager
    2296         );
    2297         fUndeclaredAttrRegistry = new (fMemoryManager) Hash2KeysSetOf<StringHasher>(7, fMemoryManager);
    2298 
    2299         if (fValidator)
    2300         {
    2301                 if (!fValidator->handlesDTD())
    2302                    ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Gen_NoDTDValidator, fMemoryManager);
    2303         }
    2304         else
    2305         {
    2306                 fValidator = fDTDValidator;
    2307         }
    2308 #endif
     2283}
     2284
     2285void DGXMLScanner::setLocator(Locator * )
     2286{
     2287    /* do nothing */
    23092288}
    23102289
  • icXML/icXML-devel/src/icxercesc/internal/DGXMLScanner.hpp

    r3104 r3564  
    100100        const XMLCh       *             content
    101101        , const XMLSize_t               contentLength
    102         , const bool                    doPSVI
    103102        , const XMLContentFlag          flags
     103        , const bool                    doPSVI       
    104104        , XMLDocumentAccumulator &      parser
    105105        , const bool                    forceWrite = false
     
    114114        const XMLCh       *             cdata
    115115        , const XMLSize_t               length
     116        , const bool                    doPSVI
    116117        , XMLDocumentAccumulator &      parser
    117118    )
     
    123124    XMLElementDecl & getElementDecl
    124125    (
    125         XMLSymbol &                   element
     126        XMLSymbol &                     element
    126127        , const unsigned int            uriId
    127         , const bool                                    isRoot
     128        , const bool                    isRoot
    128129        , const bool                    doPSVI
     130        , bool &                        hasIdentityConstraint
     131        , const bool                    error
    129132        , XMLDocumentAccumulator &      parser
    130133    )
     
    144147        , const MarkupType              type
    145148        , const Grammar::GrammarType    grammarType
    146         , const bool                    error
    147149        , const bool                    doPSVI
    148         , XMLDocumentAccumulator &      parser
    149         , const bool                    write
     150        , bool &                        error
     151        , XMLDocumentAccumulator &      parser
     152        , const bool                    write = false
    150153    )
    151154    {
     
    165168        , const Grammar::GrammarType    grammarType
    166169        , const bool                    doPSVI
     170        , bool &                        error
    167171        , XMLDocumentAccumulator &      parser
    168172    )
     
    174178    void validateEndTag
    175179    (
    176         XMLElementDecl &                element
    177         , const QName *                 elemName
    178         , const unsigned int                    uriId
    179         , const bool                                    isRoot
    180         , XMLElementDecl **                             children
    181         , const XMLSize_t                               childCount
    182         , const bool                    doPSVI
    183         , XMLDocumentAccumulator &      parser
    184     )
    185     {
    186         DEPRECATED_FEATURE_IN_ICXML;
    187     }
    188 
    189     bool toCheckIdentityConstraint() const;
     180        XMLElementDecl &                    element
     181        , const QName *                     elemName
     182        , const unsigned int                uriId
     183        , const bool                        isRoot
     184        , XMLElementDecl **                 children
     185        , const XMLSize_t                   childCount
     186        , const bool                        doPSVI
     187        , bool &                            error
     188        , XMLDocumentAccumulator &          parser
     189    )
     190    {
     191        DEPRECATED_FEATURE_IN_ICXML;
     192    }
     193
     194    // -----------------------------------------------------------------------
     195    //  IdentityConstraints Activation methods
     196    // -----------------------------------------------------------------------
     197    inline bool toCheckIdentityConstraint() const;
    190198
    191199private :
     
    219227        // -----------------------------------------------------------------------
    220228        void commonInit();
     229    void setLocator(Locator * locator);
    221230        void cleanUp();
    222231
     
    277286        //
    278287        // -----------------------------------------------------------------------
    279         ValueVectorOf<XMLAttr*>*    fAttrNSList;
    280         DTDValidator*               fDTDValidator;
    281         DTDGrammar*                 fDTDGrammar;
    282         NameIdPool<DTDElementDecl>* fDTDElemNonDeclPool;
    283         unsigned int                fElemCount;
    284         RefHashTableOf<unsigned int, PtrHasher>* fAttDefRegistry;
    285         Hash2KeysSetOf<StringHasher>*            fUndeclaredAttrRegistry;
    286 
    287 #ifdef MOVE_BUFFERS_OUT_OF_XMLSCANNER
    288         XMLBuffer                   fAttNameBuf;
    289         XMLBuffer                   fAttValueBuf;
    290         XMLBuffer                   fCDataBuf;
    291         XMLBuffer                   fQNameBuf;
    292         XMLBuffer                   fPrefixBuf;
    293         XMLBuffer                   fURIBuf;
    294         XMLBuffer                   fWSNormalizeBuf;
    295 #endif
     288    ValueVectorOf<XMLAttr*>*                    fAttrNSList;
     289    DTDValidator*                               fDTDValidator;
     290    DTDGrammar*                                 fDTDGrammar;
     291    NameIdPool<DTDElementDecl>*                 fDTDElemNonDeclPool;
     292    unsigned int                                fElemCount;
     293    RefHashTableOf<unsigned int, PtrHasher>*    fAttDefRegistry;
     294    Hash2KeysSetOf<StringHasher>*               fUndeclaredAttrRegistry;
     295    XMLBuffer                                   fAttNameBuf;
     296    XMLBuffer                                   fAttValueBuf;
     297    XMLBuffer                                   fCDataBuf;
     298    XMLBuffer                                   fQNameBuf;
     299    XMLBuffer                                   fPrefixBuf;
     300    XMLBuffer                                   fURIBuf;
     301    XMLBuffer                                   fWSNormalizeBuf;
    296302};
    297303
  • icXML/icXML-devel/src/icxercesc/internal/IGXMLScanner.cpp

    r3157 r3564  
    4747#include <icxmlc/XMLNamespaceResolver.hpp>
    4848#include <icxmlc/XMLStringU.hpp>
     49#ifdef USE_FAKE_VALIDATOR
     50#include <xercesc/validators/FakeValidator.hpp>
     51#endif
    4952
    5053XERCES_CPP_NAMESPACE_BEGIN
     
    6568        , fElemState(0)
    6669        , fElemLoopState(0)
    67         , fContent(1023, manager)
    6870        , fWSNormalizeBuf(1023, manager)
    6971        , fDTDValidator(0)
     
    7678        , fModel(0)
    7779        , fPSVIElement(0)
    78         , fErrorStack(0)
    7980        , fSchemaInfoList(0)
    8081        , fCachedSchemaInfoList (0)
     
    112113        , fElemState(0)
    113114        , fElemLoopState(0)
    114         , fContent(1023, manager)
    115115        , fWSNormalizeBuf(1023, manager)
    116116        , fDTDValidator(0)
     
    123123        , fModel(0)
    124124        , fPSVIElement(0)
    125         , fErrorStack(0)
    126125        , fSchemaInfoList(0)
    127126        , fCachedSchemaInfoList (0)
     
    356355void IGXMLScanner::commonInit()
    357356{
    358 
    359357        //  Create the element state array
    360         fElemState = (unsigned int*) fMemoryManager->allocate
    361         (
    362                 fElemStateSize * sizeof(unsigned int)
    363         ); //new unsigned int[fElemStateSize];
    364         fElemLoopState = (unsigned int*) fMemoryManager->allocate
    365         (
    366                 fElemStateSize * sizeof(unsigned int)
    367         ); //new unsigned int[fElemStateSize];
    368 
     358        fElemState = (unsigned int*) fMemoryManager->allocate(fElemStateSize * sizeof(unsigned int));
     359
     360        fElemLoopState = (unsigned int*) fMemoryManager->allocate(fElemStateSize * sizeof(unsigned int)); //new unsigned int[fElemStateSize];
     361
     362    fDTDValidator = new (fMemoryManager) DTDValidator();
    369363        //  Create the Validator and init them
    370         fDTDValidator = new (fMemoryManager) DTDValidator();
    371         initValidator(fDTDValidator);
     364    #ifdef USE_FAKE_VALIDATOR
     365    fSchemaValidator = (SchemaValidator*)new (fMemoryManager) FakeSchemaValidator(0, fMemoryManager);
     366    #else       
    372367        fSchemaValidator = new (fMemoryManager) SchemaValidator(0, fMemoryManager);
    373         initValidator(fSchemaValidator);
     368    #endif
     369
     370    initValidator(fDTDValidator);
     371    initValidator(fSchemaValidator);
    374372
    375373        // Create IdentityConstraint info
    376         fICHandler = new (fMemoryManager) IdentityConstraintHandler(this, fMemoryManager);
     374    fICHandler = new (fMemoryManager) IdentityConstraintHandler(this, fGrammarResolver->getStringPool(), fMemoryManager);
    377375
    378376        // create pools for undeclared elements
    379377        fDTDElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29, 128, fMemoryManager);
    380378    fSchemaElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager);
    381         fPSVIAttrList = new (fMemoryManager) PSVIAttributeList(fMemoryManager);
    382379
    383380        fSchemaInfoList = new (fMemoryManager) RefHash2KeysTableOf<SchemaInfo>(29, fMemoryManager);
     
    391388                fValidator = fDTDValidator;
    392389        }
     390}
     391
     392void IGXMLScanner::setLocator(Locator * locator)
     393{
     394    fDTDValidator->setLocator(locator);
     395    fSchemaValidator->setLocator(locator);
    393396}
    394397
     
    404407        delete fPSVIAttrList;
    405408        delete fPSVIElement;
    406     delete fErrorStack;
    407409        delete fSchemaInfoList;
    408410        delete fCachedSchemaInfoList;
     
    459461        return;
    460462    }
    461 
    462     //  Store the root element name for later check
    463     setRootElemName(bbRootName.getRawBuffer());
    464463
    465464    //  This element obviously is not going to exist in the element decl
     
    478477        , XMLNamespaceResolver::fEmptyUriId
    479478        , DTDElementDecl::Any
    480         , rootDeclMgr
     479        , fGrammarResolver->getStringPool()
    481480    );
     481
     482    //  Store the root element name for later check
     483    setRootElemName(const_cast<XMLCh*>(rootDecl->getRawName()));
    482484
    483485    Janitor<DTDElementDecl> rootDeclJanitor(rootDecl);
     
    10381040// ---------------------------------------------------------------------------
    10391041
    1040 bool IGXMLScanner::checkNamespaceAttribute(const XMLSymbol & attribute, const XMLCh * value, bool declared, DatatypeValidator * & attrValidator)
     1042bool IGXMLScanner::checkNamespaceAttribute(const bool isXMLNS, const XMLSymbol & attribute, const XMLCh * value, bool declared, DatatypeValidator * & attrValidator)
    10411043{
    10421044    bool validate = fValidate & declared;
    10431045    bool tokenize = false;
    10441046
    1045     if (likely(attribute.isXMLNS()))
     1047    if (likely(isXMLNS))
    10461048    {
    10471049        attrValidator = DatatypeValidatorFactory::getBuiltInRegistry()->get(SchemaSymbols::fgDT_ANYURI);
    1048         return 1;
     1050        // these values ought to be validated but the authors of Xerces reported a performance degradation of ~4%?
     1051        // they opted to disable validation with the intention of doing a performance assessment of the anyuri datatype.
     1052        // (not sure how they arrived at this figure; it seems excessive)
     1053        validate = false;
    10491054    }
    10501055    else // if (isXSI)
     
    10661071                // these values ought to be validated but the authors of Xerces reported a performance degradation of ~4%?
    10671072                // they opted to disable validation with the intention of doing a performance assessment of the anyuri datatype.
     1073                // (not sure how they arrived at this figure; it seems excessive)
     1074                validate = false;
    10681075                break;
    10691076            default:
    1070                 return 0; // bound to the xsi namespace but is not one of the predefined xsi attributes
     1077                return false; // bound to the xsi namespace but is not one of the predefined xsi attributes?
    10711078        }
    10721079    }
     
    10741081    if (validate && attrValidator)
    10751082    {
    1076         ValidationContext* const theContext = getValidationContext();
    1077 
    1078         if (theContext)
     1083        ValidationContext* const validationContext = getValidationContext();
     1084
     1085        if (validationContext)
    10791086        {
    10801087            try
     
    10851092                    while (tokenizer.hasMoreTokens())
    10861093                    {
    1087                         attrValidator->validate
    1088                         (
    1089                             tokenizer.nextToken(),
    1090                             theContext,
    1091                             fMemoryManager
    1092                         );
     1094                        attrValidator->validate(tokenizer.nextToken(), validationContext, fMemoryManager);
    10931095                    }
    10941096                }
    10951097                else
    10961098                {
    1097                     attrValidator->validate
    1098                     (
    1099                         value,
    1100                         theContext,
    1101                         fMemoryManager
    1102                     );
     1099                    attrValidator->validate(value, validationContext, fMemoryManager);
    11031100                }
    11041101            }
     
    11101107    }
    11111108
    1112     return 1;
     1109    return true;
    11131110}
    11141111
     
    11601157}
    11611158
    1162 void IGXMLScanner::endElementPSVI(SchemaElementDecl* const elemDecl, DatatypeValidator * const memberDV)
    1163 {
    1164 #if 0
    1165     PSVIElement::ASSESSMENT_TYPE validationAttempted;
    1166         PSVIElement::VALIDITY_STATE validity = PSVIElement::VALIDITY_NOTKNOWN;
    1167 
    1168         if (fPSVIElemContext.fElemDepth > fPSVIElemContext.fFullValidationDepth)
    1169     {
    1170                 validationAttempted = PSVIElement::VALIDATION_FULL;
    1171     }
    1172         else if (fPSVIElemContext.fElemDepth > fPSVIElemContext.fNoneValidationDepth)
    1173     {
    1174                 validationAttempted = PSVIElement::VALIDATION_NONE;
    1175     }
    1176         else
    1177         {
    1178                 validationAttempted  = PSVIElement::VALIDATION_PARTIAL;
    1179         fPSVIElemContext.fFullValidationDepth = fPSVIElemContext.fNoneValidationDepth = fPSVIElemContext.fElemDepth - 1;
    1180         }
    1181 
    1182         if (fValidate && elemDecl->isDeclared())
    1183         {
    1184         validity = (fPSVIElemContext.fErrorOccurred) ? PSVIElement::VALIDITY_INVALID : PSVIElement::VALIDITY_VALID;
    1185         }
    1186 
    1187         XSTypeDefinition* typeDef = 0;
    1188         bool isMixed = false;
    1189         if (fPSVIElemContext.fCurrentTypeInfo)
    1190         {
    1191                 typeDef = (XSTypeDefinition*) fModel->getXSObject(fPSVIElemContext.fCurrentTypeInfo);
    1192                 SchemaElementDecl::ModelTypes modelType = (SchemaElementDecl::ModelTypes)fPSVIElemContext.fCurrentTypeInfo->getContentType();
    1193         isMixed = (modelType == SchemaElementDecl::Mixed_Simple || modelType == SchemaElementDecl::Mixed_Complex);
    1194         }
    1195         else if (fPSVIElemContext.fCurrentDV)
    1196     {
    1197                 typeDef = (XSTypeDefinition*) fModel->getXSObject(fPSVIElemContext.fCurrentDV);
    1198     }
    1199 
    1200         XMLCh* canonicalValue = 0;
    1201     if (fPSVIElemContext.fNormalizedValue && !isMixed && validity == PSVIElement::VALIDITY_VALID)
    1202         {
    1203                 if (memberDV)
    1204                         canonicalValue = (XMLCh*) memberDV->getCanonicalRepresentation(fPSVIElemContext.fNormalizedValue, fMemoryManager);
    1205                 else if (fPSVIElemContext.fCurrentDV)
    1206                         canonicalValue = (XMLCh*) fPSVIElemContext.fCurrentDV->getCanonicalRepresentation(fPSVIElemContext.fNormalizedValue, fMemoryManager);
    1207         }
    1208 
    1209         fPSVIElement->reset
    1210         (
    1211                 validity
    1212                 , validationAttempted
    1213                 , fRootElemName
    1214                 , fPSVIElemContext.fIsSpecified
    1215         , (elemDecl->isDeclared()) ? (XSElementDeclaration*) fModel->getXSObject(elemDecl) : 0
    1216                 , typeDef
    1217                 , (memberDV) ? (XSSimpleTypeDefinition*) fModel->getXSObject(memberDV) : 0
    1218                 , fModel
    1219                 , elemDecl->getDefaultValue()
    1220                 , fPSVIElemContext.fNormalizedValue
    1221                 , canonicalValue
    1222         );
    1223 
    1224         fPSVIHandler->handleElementPSVI
    1225         (
    1226                 elemDecl->getBaseName()
    1227                 , fUriResolver->getUriForId(elemDecl->getURI())
    1228                 , fPSVIElement
    1229         );
    1230 
    1231         // decrease element depth
    1232         fPSVIElemContext.fElemDepth--;
    1233 #endif
     1159void IGXMLScanner::switchToSchemaGrammar()
     1160{
     1161    // If we are in the DTD mode, try to switch to the Schema mode. For that we need to find any
     1162    // XML Schema grammar that we can switch to. Such a grammar can only come from the cache (if
     1163    // it came from the schemaLocationattribute, we would be in the Schema mode already).
     1164
     1165    XMLGrammarPool* pool = fGrammarResolver->getGrammarPool ();
     1166    RefHashTableOfEnumerator<Grammar> i = pool->getGrammarEnumerator ();
     1167
     1168    while (i.hasMoreElements ())
     1169    {
     1170        Grammar& gr (i.nextElement());
     1171
     1172        if (gr.getGrammarType () == Grammar::SchemaGrammarType)
     1173        {
     1174            switchGrammar (gr.getTargetNamespace ());
     1175            break;
     1176        }
     1177    }
    12341178}
    12351179
     
    12381182        fPSVIElemContext.fIsSpecified = false;
    12391183        fPSVIElemContext.fErrorOccurred = false;
    1240         fPSVIElemContext.fElemDepth = -1;
    1241         fPSVIElemContext.fFullValidationDepth = -1;
    1242         fPSVIElemContext.fNoneValidationDepth = -1;
     1184    fPSVIElemContext.fElemDepth = 0;
     1185    fPSVIElemContext.fFullValidationDepth = 0;
     1186    fPSVIElemContext.fNoneValidationDepth = 0;
    12431187        fPSVIElemContext.fCurrentDV = 0;
    12441188        fPSVIElemContext.fCurrentTypeInfo = 0;
     
    12521196    , const bool                    inAttributeValue
    12531197    , XMLBuffer &                   toFill
    1254     , bool      &                   isPredefined
    1255     , bool      &                   isExternal
    1256     , XMLFileLoc &                  line
    1257     , XMLFileLoc &                  column
     1198    , XMLReplacementText &          replacementText
    12581199)
    12591200{
     
    13071248
    13081249        XMLReader * reader;
    1309 
    13101250        if (unlikely(decl->isExternal()))
    13111251        {
     
    13601300        // get the line, column and version information from the Reader; one of these will likely
    13611301        // differ from the source document.
    1362         line = reader->getLineNumber();
    1363         column = reader->getColumnNumber();
    1364         isExternal = true;
     1302        replacementText.fLine = reader->getLineNumber();
     1303        replacementText.fColumn = reader->getColumnNumber();
     1304        replacementText.fSystemId = decl->getSystemId();
     1305        replacementText.fPublicId = decl->getPublicId();
     1306        replacementText.fType = XMLReplacementText::GeneralEntity;
    13651307        // now obtain the entire the value
    13661308        reader->fill(toFill);
     1309        // and pop the entity reader off the stack
     1310        fReaderMgr.popReader();
    13671311        }
    13681312        else // internal entity
     
    13721316                {
    13731317            toFill.set(decl->getValue()[0]);
    1374             isPredefined = 1;
     1318            replacementText.fType = XMLReplacementText::PredefinedEntity;
    13751319                }
    13761320        else
    13771321        {
    1378             // line  = 0;
    1379             // column = 0;
     1322            reader = fReaderMgr.getCurrentReader();
     1323
    13801324            toFill.set(decl->getValue(), decl->getValueLen());
     1325            replacementText.fLine = decl->getBaseLine();
     1326            replacementText.fColumn = decl->getBaseColumn();
     1327            replacementText.fSystemId = reader->getSystemId();
     1328            replacementText.fPublicId = reader->getPublicId();
     1329            replacementText.fType = XMLReplacementText::GeneralEntity;
    13811330        }
    13821331        }
    13831332        return 1;
    13841333}
    1385 
    1386 
    13871334
    13881335void IGXMLScanner::reportRequiredAttribute(const DTDAttDef & attDef)
     
    14071354}
    14081355
    1409 void IGXMLScanner::reportAttributeNotDefinedForElement(const DTDElementDecl & elemDecl, const XMLCh * attributeName)
     1356void IGXMLScanner::reportRequiredAttribute(const SchemaAttDef & attDef)
    14101357{
    14111358    XMLBufBid bbAttName(&fBufMgr);
    14121359    XMLBuffer & bAttName = bbAttName.getBuffer();
     1360    const XMLCh * fullName = attDef.getFullName();
     1361    if (fDoNamespaces)
     1362    {
     1363        int colonInd = -1;
     1364        const XMLCh * uri = getURIForQName(fullName, colonInd);
     1365        if (uri)
     1366        {
     1367            bAttName.set(chOpenCurly);
     1368            bAttName.append(uri);
     1369            bAttName.append(chCloseCurly);
     1370            bAttName.append(&fullName[colonInd + 1]);
     1371            fullName = bAttName.getRawBuffer();
     1372        }
     1373    }
     1374    fSchemaValidator->emitError(XMLValid::RequiredAttrNotProvided, fullName);
     1375}
     1376
     1377
     1378void IGXMLScanner::reportAttributeNotDefinedForElement(const DTDElementDecl & elemDecl, const XMLCh * attributeName)
     1379{
     1380    XMLBufBid bbAttName(&fBufMgr);
     1381    XMLBuffer & bAttName = bbAttName.getBuffer();
     1382    const XMLCh * fullName = elemDecl.getFullName();
    14131383    if (fDoNamespaces)
    14141384    {
     
    14241394        }
    14251395    }
    1426     fDTDValidator->emitError(XMLValid::AttNotDefinedForElement, attributeName, elemDecl.getFullName());
    1427 }
    1428 
    1429 void 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);
     1396    fDTDValidator->emitError(XMLValid::AttNotDefinedForElement, attributeName, fullName);
     1397}
     1398
     1399void IGXMLScanner::endElementPSVI(SchemaElementDecl* const, DatatypeValidator * const)
     1400{
     1401    DEPRECATED_FEATURE_IN_ICXML
    14481402}
    14491403
  • icXML/icXML-devel/src/icxercesc/internal/IGXMLScanner.hpp

    r3153 r3564  
    4646#include <xercesc/framework/psvi/PSVIHandler.hpp>
    4747#include <icxercesc/validators/schema/identity/IdentityConstraintHandler.hpp>
     48#include <icxercesc/internal/ValidationContextImpl.hpp>
    4849
    4950#include <xercesc/util/XMLStringTokenizer.hpp>
     
    7374// depending on fGrammarType
    7475
    75 #define SELECT_DTD_VALIDATOR fDTDValidator // (DTDValidator*)fValidator
    76 
    77 //  This is an integrated scanner class, which does DTD/XML Schema grammar
    78 //  processing.
     76// This is an integrated scanner class, which does DTD/XML Schema grammar processing.
    7977class XMLPARSER_EXPORT IGXMLScanner : public XMLScanner
    8078{
     
    129127
    130128        // -----------------------------------------------------------------------
    131         //  XMLScanner parabix virtual methods
     129    //  XMLScanner parabix methods
    132130        // -----------------------------------------------------------------------
    133131
     
    137135        const XMLCh *                   content
    138136        , XMLSize_t                     length
     137        , const XMLContentFlag          flags
    139138        , const bool                    doPSVI
    140         , const XMLContentFlag          flags
    141139        , XMLDocumentAccumulator &      parser
    142         , const bool                    forceWrite
     140        , const bool                    write = false
    143141        );
    144142
     
    147145    (
    148146        const XMLCh       *             cdata
    149         , const XMLSize_t               length
     147        , XMLSize_t                     length
     148        , const bool                    doPSVI
    150149        , XMLDocumentAccumulator &      parser
    151150    );
     
    156155    XMLElementDecl & getElementDecl
    157156    (
    158           XMLSymbol &                   element
     157        XMLSymbol &                     element
    159158        , unsigned int &                uriId
    160         , const bool                                    isRoot
    161         , const bool                    doPSVI
     159        , const bool                    isRoot       
     160        , const bool                    doPSVI       
     161        , bool &                        hasIdentityConstraint
     162        , bool &                        error
    162163        , XMLDocumentAccumulator &      parser
    163164    );
     
    175176        , const Grammar::GrammarType    grammarType
    176177        , const bool                    doPSVI
     178        , bool &                        error
    177179        , XMLDocumentAccumulator &      parser
    178         , const bool                    write
     180        , const bool                    write = false
    179181    );
    180182
     
    190192        , const bool                    isEmpty
    191193        , const Grammar::GrammarType    grammarType
    192         , const bool                    doPSVI
     194        , const bool                    doPSVI       
     195        , bool &                        error       
    193196        , XMLDocumentAccumulator &      parser
    194197    );
     
    198201    void validateEndTag
    199202        (
    200         XMLElementDecl &                element
    201         , const QName *                 elemName
    202                 , const unsigned int                    uriId
    203                 , const bool                                    isRoot
    204                 , XMLElementDecl **                             children
    205         , const XMLSize_t                               childCount
    206         , const bool                    doPSVI
    207         , XMLDocumentAccumulator &      parser
     203        XMLElementDecl &                    element
     204        , const QName *                     elemName
     205        , const unsigned int                uriId
     206        , const bool                        isRoot
     207        , XMLElementDecl **                 children
     208        , const XMLSize_t                   childCount
     209        , const bool                        doPSVI
     210        , bool &                            error
     211        , XMLDocumentAccumulator &          parser
    208212        );
    209213
     
    234238        , const bool                    inAttributeValue
    235239        , XMLBuffer &                   toFill
    236         , bool      &                   isPredefined       
    237         , bool      &                   isExternal
    238         , XMLFileLoc &                  line
    239         , XMLFileLoc &                  column
     240        , XMLReplacementText &          replacementText
    240241    );
    241242
     
    285286        // -----------------------------------------------------------------------
    286287    void commonInit();
    287 
     288    void setLocator(Locator * locator);
    288289        void cleanUp();
    289290
    290     bool checkNamespaceAttribute(const XMLSymbol & attribute, const XMLCh * value, const bool declared, DatatypeValidator * & attrValidator);
     291    bool checkNamespaceAttribute(const bool isXMLNS, const XMLSymbol & attribute, const XMLCh * value, const bool declared, DatatypeValidator * & attrValidator);
    291292
    292293    bool tokenizeAttributeValue(const XMLCh * const value, const XMLSize_t length, XMLBuffer & toFill);
     294
     295    IDISA_ALWAYS_INLINE
     296    bool doSchemaWhitespaceNormalization(const XMLCh *& content, XMLSize_t & length);
    293297
    294298    IDISA_ALWAYS_INLINE
    295299    XMLElementDecl * findElementDecl(XMLSymbol & element, unsigned int uriId, unsigned int scope, Grammar * grammar);
    296300
    297     inline unsigned int getGrammarNamespaceId();
    298 
    299301        inline bool switchGrammar(const unsigned int uriId);
    300302
     
    308310
    309311        inline bool setCurrentGrammar(Grammar * tempGrammar);
    310 
    311     inline void endElementPSVI(SchemaElementDecl & elemDecl, DatatypeValidator * const memberDV, XMLDocumentAccumulator & parser);
    312312
    313313    IDISA_ALWAYS_INLINE
     
    354354        //  IdentityConstraints Activation methods
    355355        // -----------------------------------------------------------------------
    356         inline bool toCheckIdentityConstraint()  const;
     356    inline bool toCheckIdentityConstraint() const;
     357
     358    virtual IdentityConstraintHandler * getIdentityConstraintHandler();
    357359
    358360        // -----------------------------------------------------------------------
     
    361363        Grammar* loadXMLSchemaGrammar(const InputSource& src, const bool toCache = false);
    362364        Grammar* loadDTDGrammar(const InputSource& src, const bool toCache = false);
     365    void switchToSchemaGrammar();
    363366
    364367        // -----------------------------------------------------------------------
    365368        //  PSVI handling methods
    366369        // -----------------------------------------------------------------------
    367     void endElementPSVI(SchemaElementDecl* const elemDecl, DatatypeValidator* const memberDV);
     370
     371    inline XSModel * getPSVIModel() { return fModel; }
     372
     373    inline void endElementPSVI(SchemaElementDecl & elemDecl, XMLDocumentAccumulator & parser);
    368374
    369375        void resetPSVIElemContext();
     
    394400    void scanRawAttrListforNameSpaces(XMLSize_t);
    395401
    396     inline
    397     XMLAttDefList & getAttDefList( bool              isSchemaGrammar
    398                                  , ComplexTypeInfo*  currType
    399                                  , XMLElementDecl*   elemDecl );
    400 
    401     void updateNSMap
    402     (
    403         const   XMLCh* const    attrName
    404         , const XMLCh* const    attrValue
    405         , const int             colonPosition
    406     );
    407 
    408     void updateNSMap
    409     (
    410         const   QName* const   attrName
    411         , const XMLCh* const   attrValue
    412     );
    413 
    414     bool laxElementValidation(QName* element, ContentLeafNameTypeVector* cv, const XMLContentModel* const cm, const XMLSize_t parentElemDepth);
     402//    inline
     403//    XMLAttDefList & getAttDefList( bool              isSchemaGrammar
     404//                                 , ComplexTypeInfo*  currType
     405//                                 , XMLElementDecl*   elemDecl );
     406
     407    void updateNSMap(const XMLCh* const, const XMLCh* const, const int);
     408
     409    void updateNSMap(const QName* const, const XMLCh* const);
     410
     411    bool laxElementValidation(QName*, ContentLeafNameTypeVector*, const XMLContentModel* const, const XMLSize_t);
     412
     413    void endElementPSVI(SchemaElementDecl* const, DatatypeValidator* const);
    415414
    416415        // -----------------------------------------------------------------------
     
    458457        unsigned int*                           fElemState;
    459458        unsigned int*                           fElemLoopState;
    460         XMLBuffer                               fContent;
    461459        XMLBuffer                               fWSNormalizeBuf;
    462460        DTDValidator*                           fDTDValidator;
     
    468466        PSVIAttributeList *                     fPSVIAttrList;
    469467        XSModel*                                fModel;
    470         PSVIElement*                            fPSVIElement;
    471     ValueStackOf<bool>*                     fErrorStack;
     468        PSVIElement*                            fPSVIElement;   
    472469        PSVIElemContext                         fPSVIElemContext;
    473470        RefHash2KeysTableOf<SchemaInfo>*        fSchemaInfoList;
     
    484481inline bool IGXMLScanner::toCheckIdentityConstraint()  const
    485482{
    486         return fValidate && fIdentityConstraintChecking && fICHandler;
     483    return (getValidationScheme() != ValSchemes::Val_Never) && fIdentityConstraintChecking;
     484}
     485
     486inline IdentityConstraintHandler * IGXMLScanner::getIdentityConstraintHandler()
     487{
     488    return toCheckIdentityConstraint() ? fICHandler : 0;
    487489}
    488490
     
    505507// ---------------------------------------------------------------------------
    506508
    507 unsigned int IGXMLScanner::getGrammarNamespaceId()
    508 {
    509     unsigned int grammarUriId = fGrammar->getTargetNamespaceId();
    510     if (unlikely(grammarUriId == XMLNamespaceResolver::fUnknownUriId))
    511     {
    512         grammarUriId = fUriResolver->resolveUriId(fGrammar->getTargetNamespace());
    513         fGrammar->setTargetNamespaceId(grammarUriId);
    514     }
    515     return grammarUriId;
    516 }
    517 
    518 XMLAttDefList &
    519 IGXMLScanner::getAttDefList( bool              isSchemaGrammar
    520                                                    , ComplexTypeInfo*  currType
    521                                                    , XMLElementDecl*   elemDecl)
    522 {
    523     return (isSchemaGrammar && currType) ? currType->getAttDefList() : elemDecl->getAttDefList();
    524 }
    525 
    526509bool IGXMLScanner::switchGrammar(const unsigned int uriId)
    527510{
    528     DEBUG_GRAMMAR_MESSAGE("switchGrammar(" << uriId << ')')
    529 
    530         Grammar * grammar = fGrammarList.getGrammar(uriId);
     511    Grammar * grammar = fGrammarList.getGrammar(uriId);
    531512    const XMLCh * grammarNameSpace = NULL;
    532513        if (unlikely(grammar == NULL))
    533514        {
    534         grammarNameSpace = fUriResolver->getUriForId(uriId);
     515        grammarNameSpace = fNamespaceResolver->getUriForId(uriId);
    535516                grammar = fGrammarResolver->getGrammar(grammarNameSpace);
    536517                if (!grammar && !fSkipDTDValidation)
     
    541522                fGrammarList.setGrammar(uriId, grammar);
    542523        }
    543 
    544     DEBUG_GRAMMAR_MESSAGE("switchGrammar(" << uriId << ',' << grammarNameSpace << ")=" << grammar)
    545 
     524    assert (grammar);
     525    DEBUG_GRAMMAR_MESSAGE("switchGrammar(" << uriId << ")={" << grammarNameSpace << ',' << (grammar ? grammar->getTargetNamespace() : (XMLCh*)(0)) << '}')
    546526        return setCurrentGrammar(grammar);
    547527}
     
    560540                fGrammarList.setGrammar(uriId, grammar);
    561541        }
    562         DEBUG_GRAMMAR_MESSAGE("switchGrammar(" << uriId << ',' << newGrammarNameSpace << ")=" << grammar)
     542    assert (grammar);
     543    DEBUG_GRAMMAR_MESSAGE("switchGrammar(" << uriId << ',' << newGrammarNameSpace << ")=" << (grammar ? grammar->getTargetNamespace() : (XMLCh*)(0)))
    563544        return setCurrentGrammar(grammar);
    564545}
     
    566547bool IGXMLScanner::switchGrammar(const XMLCh* const newGrammarNameSpace)
    567548{
    568     return switchGrammar(fUriResolver->resolveUriId(newGrammarNameSpace), newGrammarNameSpace);
     549    return switchGrammar(fNamespaceResolver->resolveUriId(newGrammarNameSpace), newGrammarNameSpace);
    569550}
    570551
     
    651632      XMLSymbol &                   element
    652633    , unsigned int &                uriId
    653     , const bool                                        isRoot
     634    , const bool                                        isRoot   
    654635    , const bool                    doPSVI
     636    , bool &                        hasIdentityConstraint
     637    , bool &                        error
    655638    , XMLDocumentAccumulator &      parser   
    656639)
     
    658641    /// ----------------------------- DETERMINE THE ELEMENT DECLARATION -----------------------------------
    659642
    660     fContent.reset();
    661     XMLElementDecl * elemDecl = 0;
    662 
    663     fPSVIElemContext.fErrorOccurred = false;
     643    XMLElementDecl * elemDecl = 0;   
     644
    664645    if (unlikely(!fDoNamespaces))
    665646    {
     
    677658        {           
    678659            elemDecl = fDTDElemNonDeclPool->getByKey(element.getName());
    679             DEBUG_GRAMMAR_MESSAGE("fDTDElemNonDeclPool->getByKey(" << element.getName() << ")=" << elemDecl)
    680660            if (!elemDecl)
    681661            {
     
    714694        XMLContentModel* cm = 0;
    715695        unsigned int currentScope = Grammar::TOP_LEVEL_SCOPE;
    716         bool laxThisOne = false;
    717 
    718         bool bXsiTypeSet = false;
     696        bool laxValidation = false;
     697        bool hasXsiType = false;
    719698        bool wasAdded = false;
    720699
    721700        if (fGrammarType == Grammar::SchemaGrammarType)
    722701        {
    723             bXsiTypeSet = fSchemaValidator->getIsXsiTypeSet();
     702            hasXsiType = fSchemaValidator->getIsXsiTypeSet();
    724703
    725704            if (likely(!isRoot))
     
    731710                {
    732711                    // schema validator will have correct type if validating
    733                     currType = fSchemaValidator->getCurrentTypeInfo();
     712                    currType = fSchemaValidator->getCurrentTypeInfo();                   
    734713                    modelType = currType ? (SchemaElementDecl::ModelTypes)currType->getContentType() : SchemaElementDecl::Any;
    735714                }
     
    750729                        currentScope = fElemStack.getCurrentScope();
    751730                        //if schema, check if we should lax or skip the validation of this element
    752                         laxThisOne = laxElementValidation(element.getQName(), uriId, cv, cm, fElemStack.getLevel());
     731                        laxValidation = laxElementValidation(element.getQName(), uriId, cv, cm, fElemStack.getLevel());
    753732                        break;
    754733                    case SchemaElementDecl::Any:
    755                         laxThisOne = true;
     734                        laxValidation = true;
    756735                }
    757736            }
    758737
    759738            elemDecl = findElementDecl(element, uriId, currentScope, fGrammar);
    760 
    761             if (unlikely(elemDecl == 0))
     739            if (unlikely(!elemDecl))
    762740            {               
    763741                if (likely(fDoSchema))
    764742                {
    765                     const unsigned int grammarUriId = getGrammarNamespaceId();
     743                    const unsigned int grammarUriId = fGrammar->getTargetNamespaceId(fNamespaceResolver);
     744
    766745                    Grammar * const originalGrammar = fGrammar;
    767746                    if (unlikely(grammarUriId != uriId))
     
    771750                            elemDecl = findElementDecl(element, uriId, currentScope, fGrammar);
    772751                        }
    773                         else if (unlikely(!laxThisOne && fValidate))
     752                        else if (unlikely(!laxValidation && fValidate))
    774753                        {
    775754                            // the laxElementValidation routine (called above) will
    776755                            // set fValidate to false for a "skipped" element
    777                             fSchemaValidator->emitError(XMLValid::GrammarNotFound, fUriResolver->getUriForId(uriId));
     756                            fSchemaValidator->emitError(XMLValid::GrammarNotFound, fNamespaceResolver->getUriForId(uriId));
    778757                        }
    779758                    }
    780759
    781                     if (unlikely(elemDecl == 0 && (currentScope != Grammar::TOP_LEVEL_SCOPE)))
     760                    if (unlikely(!elemDecl && (currentScope != Grammar::TOP_LEVEL_SCOPE)))
    782761                    {
    783762                        // try the top level
    784763                        elemDecl = findElementDecl(element, uriId, Grammar::TOP_LEVEL_SCOPE, fGrammar);
    785 
    786764                        if (unlikely(elemDecl == 0 && fValidate))
    787765                        {
    788766                            if (grammarUriId == uriId)
    789767                            {
    790                                 // still not found in specified uri; try emptyNamespace see if element should be un-qualified.
     768                                // still not found in specified uri; try emptyNamespace see if the element should be un-qualified.
    791769                                if (uriId != XMLNamespaceResolver::fEmptyUriId)
    792770                                {
     
    802780                            else if (uriId == XMLNamespaceResolver::fEmptyUriId)
    803781                            {
    804                                 // still Not found in specified uri
    805                                 // go to original Grammar again to see if element needs
    806                                 // to be fully qualified.
    807                                 // Use a temp variable until we decide this is the case
    808 
     782                                // still not found in specified uri; try the original grammar to see if the element needs to be fully qualified.
    809783                                if (originalGrammar)
    810784                                {
     
    820794                                    }
    821795                                }
    822                                 else if (!laxThisOne)
     796                                else if (!laxValidation)
    823797                                {
    824798                                    fSchemaValidator->emitError(XMLValid::GrammarNotFound, originalGrammar->getTargetNamespace());
     
    830804                    if (unlikely(elemDecl == 0))
    831805                    {
    832                         DEBUG_GRAMMAR_MESSAGE("fSchemaElemNonDeclPool->getByKey(" << element.getQName()->getLocalPart() << ',' << uriId << ',' << Grammar::TOP_LEVEL_SCOPE << ')')
    833 
    834806                        fGrammar = originalGrammar;
    835807                        fGrammarType = Grammar::SchemaGrammarType;
     
    841813                }
    842814
    843                 if (unlikely(elemDecl == 0))
     815                if (unlikely(!elemDecl))
    844816                {
    845817                    //  Could not find the element declaration; fault one in.
    846818                    elemDecl = new (fMemoryManager) SchemaElementDecl(element.getQName(), SchemaElementDecl::Any, Grammar::TOP_LEVEL_SCOPE, fMemoryManager);
    847                     elemDecl->setId(fSchemaElemNonDeclPool->put((void*)elemDecl->getBaseName(), uriId, (int)Grammar::TOP_LEVEL_SCOPE, (SchemaElementDecl*)elemDecl));
     819                    fSchemaElemNonDeclPool->put((void*)element.getQName()->getLocalPart(), uriId, (int)Grammar::TOP_LEVEL_SCOPE, (SchemaElementDecl*)elemDecl);
    848820                    elemDecl->setCreateReason(XMLElementDecl::JustFaultIn);
    849821                    element.setElemDecl(uriId, currentScope, elemDecl);
     
    852824
    853825                element.setElemDecl(uriId, currentScope, elemDecl);
     826
     827                if (unlikely((static_cast<const SchemaElementDecl*>(elemDecl)->getIdentityConstraintCount() > 0)))
     828                {
     829                    hasIdentityConstraint = fIdentityConstraintChecking;
     830                    DEBUG_GRAMMAR_MESSAGE(" *** hasIdentityConstraint *** ")
     831                }
     832            }
     833
     834            if (doPSVI)
     835            {
     836                fPSVIElemContext.fElemDepth++;
     837                if (elemDecl->isDeclared())
     838                {
     839                    fPSVIElemContext.fNoneValidationDepth = fPSVIElemContext.fElemDepth;
     840                }
     841                else
     842                {
     843                    fPSVIElemContext.fFullValidationDepth = fPSVIElemContext.fElemDepth;
     844                }
    854845            }
    855846        }
     
    864855                    if (unlikely(!switchGrammar(uriId)))
    865856                    {
    866                         fDTDValidator->emitError(XMLValid::GrammarNotFound, fUriResolver->getUriForId(uriId));
     857                        fDTDValidator->emitError(XMLValid::GrammarNotFound, fNamespaceResolver->getUriForId(uriId));
    867858                    }
    868859                }
     
    882873
    883874
    884         if (!elemDecl->isDeclared())
    885         {
    886             DEBUG_GRAMMAR_MESSAGE(" --- faulting element in! laxThisOne=" << laxThisOne << " bXsiTypeSet=" << bXsiTypeSet)
    887 
    888             if (laxThisOne && !bXsiTypeSet)
     875        if (unlikely(!elemDecl->isDeclared()))
     876        {
     877            DEBUG_GRAMMAR_MESSAGE(" --- faulting element in! laxValidation=" << laxValidation << ", hasXsiType=" << hasXsiType)
     878
     879            if (laxValidation && !hasXsiType)
    889880            {
    890881                fValidate = false;
     
    893884            {
    894885                // if xsi:type was specified, don't complain about missing definition
    895                 if (!bXsiTypeSet)
     886                if (!hasXsiType)
    896887                {
    897888                    fValidator->emitError(XMLValid::ElementNotDefined, elemDecl->getFullName());
    898                     fPSVIElemContext.fErrorOccurred = true;
     889                    error = true;
    899890                }
    900891            }
     
    907898        if (fGrammarType == Grammar::SchemaGrammarType)
    908899        {
    909             DEBUG_MESSAGE("fSchemaValidator->validateElement(elemDecl);")
    910 
    911900            ComplexTypeInfo * typeInfo;
    912901            if (fValidate)
    913902            {
    914903                fSchemaValidator->validateElement(elemDecl);
    915                 fPSVIElemContext.fErrorOccurred |= fSchemaValidator->getErrorOccurred();
     904                error |= fSchemaValidator->getErrorOccurred();
    916905                typeInfo = fSchemaValidator->getCurrentTypeInfo();
    917906            }
     
    920909                typeInfo = ((SchemaElementDecl*)elemDecl)->getComplexTypeInfo();
    921910            }
     911
     912            DEBUG_MESSAGE(" -- typeInfo=" << typeInfo << ", validate=" << fValidate)
    922913
    923914            if (typeInfo)
     
    933924                    const XMLCh* uri = prefixBuf.getRawBuffer();
    934925                    bool switched = switchGrammar(uri);
    935                     if (!switched && !laxThisOne && fValidate)
     926                    if (!switched && !laxValidation && fValidate)
    936927                    {
    937928                        fSchemaValidator->emitError(XMLValid::GrammarNotFound, uri);
     
    941932                {
    942933                    bool switched = switchGrammar(XMLNamespaceResolver::fEmptyUriId);
    943                     if (!switched && !laxThisOne && fValidate)
     934                    if (!switched && !laxValidation && fValidate)
    944935                    {
    945936                        fSchemaValidator->emitError(XMLValid::GrammarNotFound, XMLUni::fgZeroLenString);
     
    987978    }
    988979
    989     assert (elemDecl != 0);
    990 
    991980    return *elemDecl;
    992981}
     
    994983XMLElementDecl * IGXMLScanner::findElementDecl(XMLSymbol & element, unsigned int uriId, unsigned int scope, Grammar * grammar)
    995984{   
    996     DEBUG_MESSAGE(" -- findElementDecl(" << element << ',' << uriId << ',' << scope << ',' << grammar << ')')
    997985    size_t index;
    998986    XMLElementDecl * elemDecl = element.getElemDecl(uriId, scope, index);
    999     if (unlikely(elemDecl == 0))
    1000     {
    1001         assert (grammar != 0);
    1002         elemDecl = grammar->getElemDecl(uriId, element.getQName()->getLocalPart(), element.getQName()->getRawName(), scope);
    1003         if (elemDecl)
     987    if (unlikely(!elemDecl))
     988    {
     989        QName * const qName = element.getQName();
     990        elemDecl = grammar->getElemDecl(uriId, qName->getLocalPart(), qName->getRawName(), scope);
     991        if (likely(elemDecl != NULL))
    1004992        {
    1005993            element.setElemDecl(index, uriId, scope, elemDecl);
     
    1007995    }
    1008996    return elemDecl;
     997}
     998
     999static inline const XMLCh * subsituteEmptyStringWithNull(const XMLCh * string)
     1000{
     1001    if (unlikely(string && *string == 0))
     1002        string = 0;
     1003    return string;
    10091004}
    10101005
     
    10201015    , const Grammar::GrammarType    grammarType
    10211016    , const bool                    doPSVI
     1017    , bool &                        error
    10221018    , XMLDocumentAccumulator &      parser
    10231019    , const bool                    write
     
    10531049            {
    10541050                reportAttributeNotDefinedForElement(dtdElemDecl, attribute.getName());
     1051                error = true;
    10551052            }
    10561053        }
     
    10911088        }
    10921089
    1093         if (unlikely(type & Surpressed)) return 0;
    1094 
    10951090        parser.writeAttribute(attribute.getQName(), attType, uriId, value, length, type, write | tokenized);
    10961091    }
     
    11001095        SchemaAttDef * attDef = 0;
    11011096        const QName * attName = attribute.getQName();
     1097        DatatypeValidator * attrValidator = 0;       
     1098        bool normalized = false;
     1099        bool laxValidation = false;
     1100        bool skipValidation = false;
    11021101        PSVIItem::VALIDITY_STATE attrValid = PSVIItem::VALIDITY_VALID;
    11031102        PSVIItem::ASSESSMENT_TYPE attrAssessed = PSVIItem::VALIDATION_FULL;
    1104         DatatypeValidator * attrValidator = 0;       
    1105         bool normalized = false;
    11061103
    11071104        //  If the uri comes back as the xmlns or xml URI or its just a name
     
    11121109        const bool isXSI = (uriId == XMLNamespaceResolver::fSchemaInstanceUriId);
    11131110        const bool isXMLNS = (uriId == XMLNamespaceResolver::fXMLNSUriId);
    1114         bool isNamespaceAttribute = (isXSI | isXMLNS);
    1115 
    1116         if (unlikely(isNamespaceAttribute))
    1117         {
    1118             isNamespaceAttribute = checkNamespaceAttribute(attribute, value, elemDecl.isDeclared(), attrValidator);
    1119             if (likely(isNamespaceAttribute))
    1120             {
    1121                 attrValid = PSVIItem::VALIDITY_NOTKNOWN;
    1122                 attrAssessed = PSVIItem::VALIDATION_NONE;
    1123                 if (type & Surpressed) return 0;
    1124             }
    1125         }
    1126 
    1127         if (likely(!isNamespaceAttribute))
     1111
     1112        if (unlikely(isXSI | isXMLNS))
     1113        {
     1114            skipValidation = checkNamespaceAttribute(isXMLNS, attribute, value, elemDecl.isDeclared(), attrValidator);
     1115        }
     1116
     1117        if (likely(!skipValidation))
    11281118        {
    11291119            // Some checking for attribute wild card first (for schema)
    1130             bool laxThisOne = false;
    1131             bool skipThisOne = false;
    1132 
    1133             ComplexTypeInfo *currType = 0;
    1134             DatatypeValidator *currDV = 0;
     1120            SchemaAttDef* attWildCard = 0;
    11351121
    11361122            const XMLCh* const localPart = attName->getLocalPart();
    11371123
    1138             if (fValidate)
    1139             {
    1140                 currType = fSchemaValidator->getCurrentTypeInfo();
    1141                 if (!currType)
    1142                 {
    1143                     currDV = fSchemaValidator->getCurrentDatatypeValidator();
    1144                 }
    1145             }
    1146 
    1147             //retrieve the att def
    1148             SchemaAttDef* attWildCard = 0;
     1124            ComplexTypeInfo * const currType = fSchemaValidator->getCurrentTypeInfo();
     1125            //retrieve the att def and wildcard
    11491126            if (currType)
    11501127            {
     
    11521129                attWildCard = currType->getAttWildCard();
    11531130            }
    1154             else if (!currDV)
     1131            else if (!fSchemaValidator->getCurrentDatatypeValidator())
    11551132            {
    11561133                // check explicitly-set wildcard
     
    11621139            // if no matching wildcard attribute, check (un)qualifed cases and flag
    11631140            // appropriate errors
    1164             if (!attDef || (attDef->getCreateReason() == XMLAttDef::JustFaultIn))
     1141            if (unlikely(!attDef || (attDef->getCreateReason() == XMLAttDef::JustFaultIn)))
    11651142            {
    11661143                if (attWildCard)
    11671144                {
    11681145                    //if schema, see if we should lax or skip the validation of this attribute
    1169                     if (anyAttributeValidation(attWildCard, uriId, skipThisOne, laxThisOne))
     1146                    if (anyAttributeValidation(attWildCard, uriId, skipValidation, laxValidation))
    11701147                    {
    1171                         if (!skipThisOne)
     1148                        if (!skipValidation)
    11721149                        {
    11731150                            Grammar* sGrammar = fGrammarList.getGrammar(uriId);
    11741151                            if (unlikely(sGrammar == NULL))
    11751152                            {
    1176                                 sGrammar = fGrammarResolver->getGrammar((*fUriResolver)[uriId]);
     1153                                sGrammar = fGrammarResolver->getGrammar((*fNamespaceResolver)[uriId]);
    11771154                                fGrammarList.setGrammar(uriId, sGrammar);
    11781155                            }
     
    11921169                {
    11931170                    const unsigned int tempUriId =
    1194                         (uriId == XMLNamespaceResolver::fEmptyUriId)
    1195                             ? fUriResolver->resolveUriId(fGrammar->getTargetNamespace()) // NOTE: should this just be elementUriId? verify!
    1196                             : XMLNamespaceResolver::fEmptyUriId;
     1171                        (uriId == XMLNamespaceResolver::fEmptyUriId) ? fGrammar->getTargetNamespaceId(fNamespaceResolver) : XMLNamespaceResolver::fEmptyUriId;
    11971172
    11981173                    // not found, see if the attDef should be qualified or not
     
    12051180                            ? XMLValid::AttributeNotQualified
    12061181                            : XMLValid::AttributeNotUnQualified;
    1207 
    1208                         fSchemaValidator->emitError(errCode, attDef->getFullName());
    1209                         fPSVIElemContext.fErrorOccurred = true;
     1182                        fSchemaValidator->emitError(errCode, attDef->getFullName());                       
    12101183                        attrValid = PSVIItem::VALIDITY_INVALID;
    12111184                    }
     
    12131186            } // if (!attDef || (attDef->getCreateReason() == XMLAttDef::JustFaultIn))
    12141187
    1215             if (attDef)
     1188            if (likely(!!attDef))
    12161189            {
    12171190                attDef->setLastOccurrence(elementCount);
    12181191                attType = attDef->getType();
    1219                 if (unlikely(attDef->getDefaultType() == XMLAttDef::Prohibited) && fValidate)
     1192
     1193                if (unlikely(attDef->getDefaultType() == XMLAttDef::Prohibited))
    12201194                {
    12211195                    // (schema) report error for PROHIBITED attrs that are present (V_TAGc)
    12221196                    fSchemaValidator->emitError(XMLValid::ProhibitedAttributePresent, attDef->getFullName());
    1223                     fPSVIElemContext.fErrorOccurred = true;
    12241197                    attrValid = PSVIItem::VALIDITY_INVALID;
    12251198                }
    1226             }
    1227             else // if (!attDef && !attDefForWildCard)
    1228             {
    1229                 if (unlikely(fValidate && !isNamespaceAttribute && !(laxThisOne | skipThisOne)))
    1230                 {
    1231                     fPSVIElemContext.fErrorOccurred = true;
    1232                     attrValid = PSVIItem::VALIDITY_INVALID;
    1233                     reportUndefinedAttribute(uriId, attribute.getQName(), schemaElemDecl);
    1234                 }
    12351199                else
    12361200                {
    1237                     attrValid = PSVIItem::VALIDITY_NOTKNOWN;
    1238                     attrAssessed = (laxThisOne) ? PSVIItem::VALIDATION_PARTIAL : PSVIItem::VALIDATION_NONE;
    1239                 }
    1240             }
    1241 
    1242             /// VALIDATE THE ATTRIBUTE VALUE BASED ON THE DEFINITION
    1243             if (attDef && fValidate)
    1244             {
    1245                 //  Normalize the raw value since we have the attribute type. We
    1246                 //  don't care about the return status here. If it failed, an error
    1247                 //  will be issued, which is all we care about.
    1248 
    1249                 const XMLCh * normalizedValue = value;
    1250                 XMLSize_t normalizedLength = length;
    1251 
    1252                 DatatypeValidator* tempDV = attDef->getDatatypeValidator();
    1253                 if (tempDV && tempDV->getWSFacet() != DatatypeValidator::PRESERVE)
    1254                 {
    1255                     fSchemaValidator->normalizeWhiteSpace(tempDV->getWSFacet(), value, fWSNormalizeBuf, length, true);
    1256                     normalizedValue = fWSNormalizeBuf.getRawBuffer();
    1257                     normalizedLength = fWSNormalizeBuf.getLen();
    1258                 }
    1259 
    1260                 fSchemaValidator->validateAttrValue(attDef, normalizedValue, false, &schemaElemDecl);
    1261 
    1262                 attrValidator = fSchemaValidator->getMostRecentAttrValidator();
    1263 
    1264                 if (unlikely(fSchemaValidator->getErrorOccurred()))
    1265                 {
    1266                     fPSVIElemContext.fErrorOccurred = true;
    1267                     attrValid = PSVIItem::VALIDITY_INVALID;
    1268                 }
    1269 
    1270                 if (fNormalizeData)
    1271                 {
    1272                     value = normalizedValue;
    1273                     length = normalizedLength;
    1274                     normalized = true;
    1275                 }
     1201                    //  Normalize the raw value since we have the attribute type. We
     1202                    //  don't care about the return status here. If it failed, an error
     1203                    //  will be issued, which is all we care about.
     1204
     1205                    const XMLCh * normalizedValue = value;
     1206                    XMLSize_t normalizedLength = length;
     1207
     1208                    DatatypeValidator* tempDV = attDef->getDatatypeValidator();
     1209                    if (tempDV && tempDV->getWSFacet() != DatatypeValidator::PRESERVE)
     1210                    {
     1211                        fSchemaValidator->normalizeWhiteSpace(tempDV->getWSFacet(), value, fWSNormalizeBuf, length, true);
     1212                        normalizedValue = fWSNormalizeBuf.getRawBuffer();
     1213                        normalizedLength = fWSNormalizeBuf.getLen();
     1214                    }
     1215
     1216                    if (fValidate && !skipValidation)
     1217                    {
     1218                        fSchemaValidator->validateAttrValue(attDef, normalizedValue, false, &schemaElemDecl);
     1219                        attrValidator = fSchemaValidator->getMostRecentAttrValidator();
     1220                        if (unlikely(fSchemaValidator->getErrorOccurred()))
     1221                        {
     1222                            attrValid = PSVIItem::VALIDITY_INVALID;
     1223                        }
     1224                    }
     1225
     1226                    if (fNormalizeData)
     1227                    {
     1228                        value = normalizedValue;
     1229                        length = normalizedLength;
     1230                        normalized = true;
     1231                    }
     1232                }
     1233            }
     1234            else if (unlikely(!laxValidation && !skipValidation && fValidate))
     1235            {
     1236                reportUndefinedAttribute(uriId, attribute.getQName(), schemaElemDecl);
     1237                attrValid = PSVIItem::VALIDITY_INVALID;
    12761238            }
    12771239            else
    1278             {   // no decl; default DOMTypeInfo to anySimpleType
    1279                 attrValidator = getAnySimpleTypeValidator();
    1280             }
     1240            {
     1241                attrValid = PSVIItem::VALIDITY_NOTKNOWN;
     1242                attrAssessed = laxValidation ? PSVIItem::VALIDATION_PARTIAL : PSVIItem::VALIDATION_NONE;
     1243            }
     1244        }
     1245        else
     1246        {
     1247            attrValid = PSVIItem::VALIDITY_NOTKNOWN;
     1248            attrAssessed = PSVIItem::VALIDATION_NONE;
    12811249        }
    12821250
     
    12881256            XSSimpleTypeDefinition * memberType = 0;
    12891257            XSSimpleTypeDefinition * validatingType = 0;
    1290             DatatypeValidator * dataValidator = 0;
    1291             if (attDef)
     1258            const XMLCh * defaultValue = 0;           
     1259
     1260            if (likely(!!attDef))
    12921261            {
    12931262                attrDecl = (XSAttributeDeclaration *)fModel->getXSObject(attDef);
    12941263                DatatypeValidator * attrDataType = attDef->getDatatypeValidator();
    12951264                validatingType = (XSSimpleTypeDefinition *)fModel->getXSObject(attrDataType);
    1296                 if (attrValid == PSVIItem::VALIDITY_VALID)
    1297                 {
    1298                     if (validatingType->getVariety() == XSSimpleTypeDefinition::VARIETY_UNION)
     1265                defaultValue = attDef->getValue();
     1266                if (unlikely(attrValidator == 0))
     1267                {
     1268                    attrValidator = getAnySimpleTypeValidator();
     1269                }
     1270                if (likely(attrValid == PSVIItem::VALIDITY_VALID))
     1271                {
     1272                    if (unlikely(validatingType->getVariety() == XSSimpleTypeDefinition::VARIETY_UNION))
    12991273                    {
    13001274                        memberType = (XSSimpleTypeDefinition *)fModel->getXSObject(attrValidator);
    1301                         dataValidator = (memberType) ? attrValidator : attrDataType;
    13021275                    }
    1303                 }
    1304             }
    1305             parser.writeAttributePSVI(attrDecl, memberType, validatingType, attrValid, attrAssessed, dataValidator);
    1306         }
    1307     }
     1276                    attrValidator = (memberType) ? attrValidator : attrDataType;
     1277                }
     1278            }
     1279            else if (attrValidator)
     1280            {
     1281                validatingType = (XSSimpleTypeDefinition *)fModel->getXSObject(attrValidator);
     1282            }
     1283
     1284            parser.writeAttributePSVI(attrDecl, validatingType, memberType, defaultValue, attrValid, attrAssessed, attrValidator, false);
     1285        }
     1286
     1287        if (unlikely(attrValid == PSVIItem::VALIDITY_INVALID))
     1288        {
     1289            error = true;
     1290        }
     1291    }
     1292
    13081293    return 1;
    13091294}
     
    13191304    , const bool                                        isEmpty
    13201305    , const Grammar::GrammarType    grammarType
    1321     , const bool                    doPSVI
     1306    , const bool                    doPSVI   
     1307    , bool &                        error   
    13221308    , XMLDocumentAccumulator &      parser
    13231309)
     
    13601346        {
    13611347            ComplexTypeInfo * currType = 0;
    1362             DatatypeValidator * currDV = 0;
    1363 
    13641348            SchemaElementDecl & schemaElemDecl = reinterpret_cast<SchemaElementDecl&>(elemDecl);
    13651349
    13661350            currType = fSchemaValidator->getCurrentTypeInfo();
    1367             if (!currType)
    1368             {
    1369                 currDV = fSchemaValidator->getCurrentDatatypeValidator();
    1370             }
    13711351
    13721352            const bool hasDefs = (currType) ? currType->hasAttDefs() : schemaElemDecl.hasAttDefs();
     
    13941374                    if (unlikely(attDef.getLastOccurrence() != elementCount))
    13951375                    {
    1396                         // note that since there is no attribute information
    1397                         // item present, there is no PSVI infoset to augment here *except*
    1398                         // that the element is invalid
    1399 
    14001376                        //the attribute is not provided
    14011377                        if ((defType == XMLAttDef::Required) || (defType == XMLAttDef::Required_And_Fixed))
    14021378                        {
    14031379                            reportRequiredAttribute(attDef);
    1404                             fPSVIElemContext.fErrorOccurred = true;
     1380                            error = true;
    14051381                        }
    14061382                        else if ((defType == XMLAttDef::Default) || (defType == XMLAttDef::Fixed))
     
    14111387                                // Document is standalone, so attributes must not be defaulted.
    14121388                                fSchemaValidator->emitError(XMLValid::NoDefAttForStandalone, attDef.getFullName(), schemaElemDecl.getFullName());
    1413                                 fPSVIElemContext.fErrorOccurred = true;
     1389                                error = true;
    14141390                            }
    14151391
     
    14171393                            fSchemaValidator->validateAttrValue(&attDef, attDef.getValue(), false, &schemaElemDecl);
    14181394
    1419                             parser.writeAttribute(attDef.getAttName(), attDef.getType(), getURIIdForPrefix(attDef.getAttName()->getPrefix()), attDef.getValue(), XMLString::stringLen(attDef.getValue()), SchemaDefaultAttribute);
     1395                            parser.writeAttribute(attDef.getAttName(), attDef.getType(), attDef.getAttName()->getURI(), attDef.getValue(), XMLString::stringLen(attDef.getValue()), SchemaDefaultAttribute, false);
    14201396
    14211397                            if (doPSVI)
     
    14231399                                XSAttributeDeclaration * attrDecl = (XSAttributeDeclaration *)fModel->getXSObject((void*)&attDef);
    14241400                                DatatypeValidator * attrValidator = attDef.getDatatypeValidator();
    1425                                 XSSimpleTypeDefinition *validatingType = 0;
    1426                                 PSVIItem::VALIDITY_STATE attrValid = PSVIItem::VALIDITY_INVALID;
     1401                                XSSimpleTypeDefinition *validatingType = (XSSimpleTypeDefinition*)fModel->getXSObject(attrValidator);
     1402                                PSVIItem::VALIDITY_STATE attrValid = PSVIItem::VALIDITY_VALID;
    14271403                                XSSimpleTypeDefinition * memberType = 0;
    14281404                                // check if any error occurred during the validation of default value
    1429                                 if (likely(!fSchemaValidator->getErrorOccurred()))
     1405                                if (unlikely(fSchemaValidator->getErrorOccurred()))
    14301406                                {
    1431                                     attrValid = PSVIItem::VALIDITY_VALID;
    1432                                     validatingType = (XSSimpleTypeDefinition*)fModel->getXSObject(attrValidator);
    1433                                     if (validatingType->getVariety() == XSSimpleTypeDefinition::VARIETY_UNION)
     1407                                    attrValidator = 0;
     1408                                    attrValid = PSVIItem::VALIDITY_INVALID;
     1409                                }
     1410                                else if (validatingType->getVariety() == XSSimpleTypeDefinition::VARIETY_UNION)
     1411                                {
     1412                                    DatatypeValidator * mostRecentAttrValidator = fSchemaValidator->getMostRecentAttrValidator();
     1413                                    memberType = (XSSimpleTypeDefinition*)fModel->getXSObject(mostRecentAttrValidator);
     1414                                    if (memberType)
    14341415                                    {
    1435                                         DatatypeValidator * mostRecentAttrValidator = fSchemaValidator->getMostRecentAttrValidator();
    1436                                         memberType = (XSSimpleTypeDefinition*)fModel->getXSObject(mostRecentAttrValidator);
    1437                                         if (memberType)
    1438                                         {
    1439                                             attrValidator = mostRecentAttrValidator;
    1440                                         }
     1416                                        attrValidator = mostRecentAttrValidator;
    14411417                                    }
    14421418                                }
    1443                                 parser.writeAttributePSVI(attrDecl, memberType, validatingType, attrValid, PSVIItem::VALIDATION_FULL, attrValidator);
     1419                                parser.writeAttributePSVI(attrDecl, validatingType, memberType, attDef.getValue(), attrValid, PSVIItem::VALIDATION_FULL, attrValidator, true);
    14441420                            }
    14451421                            // increase the attributeCount
     
    14541430    /// ------------------------------ END OF TAG HANDLING ---------------------------------
    14551431
     1432    parser.writeStartTag(elemDecl, elemName, uriId, attributeCount, isEmpty);
     1433
    14561434    //  If empty, validate content right now if we are validating and then
    14571435    //  pop the element stack top. Else, we have to update the current stack
     
    14631441
    14641442        if (grammarType == Grammar::DTDGrammarType)
    1465         {
    1466             parser.writeStartTag(elemDecl, elemName, uriId, attributeCount, true);
    1467 
     1443        {                       
    14681444            // If validating, then insure that its legal to have no content
    14691445            if (fValidate)
     
    14731449                {
    14741450                    fDTDValidator->emitError(XMLValid::ElementNotValidForContent, elemDecl.getFullName(), elemDecl.getFormattedContentModel());
    1475                 }
    1476             }
    1477 
     1451                    error = true;
     1452                }
     1453            }               
    14781454        }
    14791455        else // if (grammarType == Grammar::SchemaGrammarType)
    14801456        {
    1481             DatatypeValidator* psviMemberType = 0;
    1482             bool isSpecified = false;
     1457            const Grammar::GrammarType grammarType = fGrammarType;
     1458
     1459            if (likely(grammarType == Grammar::SchemaGrammarType))
     1460            {
     1461                // reset error occurred
     1462                if (fValidate && elemDecl.isDeclared())
     1463                {
     1464                    fPSVIElemContext.fCurrentTypeInfo = fSchemaValidator->getCurrentTypeInfo();
     1465                    fPSVIElemContext.fCurrentDV = fPSVIElemContext.fCurrentTypeInfo ? 0 : fSchemaValidator->getCurrentDatatypeValidator();
     1466                    fPSVIElemContext.fNormalizedValue = doPSVI ? subsituteEmptyStringWithNull(fSchemaValidator->getNormalizedValue()) : 0;
     1467                }
     1468                else
     1469                {
     1470                    fPSVIElemContext.fCurrentDV = 0;
     1471                    fPSVIElemContext.fCurrentTypeInfo = 0;
     1472                    fPSVIElemContext.fNormalizedValue = 0;
     1473                }
     1474            }
     1475
    14831476            if (fValidate)
    1484             {
    1485                 // If validating, then insure that its legal to have no content
     1477            {               
     1478                bool hasSpecifiedValue = false;
    14861479                XMLSize_t failure;
     1480
     1481                // reset current type info
     1482                if (likely(elemDecl.isDeclared()))
     1483                {
     1484                    fPSVIElemContext.fCurrentTypeInfo = fSchemaValidator->getCurrentTypeInfo();
     1485                    fPSVIElemContext.fCurrentDV = fPSVIElemContext.fCurrentTypeInfo ? 0 : fSchemaValidator->getCurrentDatatypeValidator();
     1486                    fPSVIElemContext.fNormalizedValue = doPSVI ? subsituteEmptyStringWithNull(fSchemaValidator->getNormalizedValue()) : 0;
     1487                }
     1488                else
     1489                {
     1490                    fPSVIElemContext.fCurrentTypeInfo = 0;
     1491                    fPSVIElemContext.fCurrentDV = 0;
     1492                    fPSVIElemContext.fNormalizedValue = 0;
     1493                }
     1494                fPSVIElemContext.fIsSpecified = false;
     1495
     1496
     1497                // If validating, then ensure that it's legal to have no content
    14871498                if (unlikely(!fSchemaValidator->checkContent(&elemDecl, ((XMLElementDecl**)0), 0, &failure)))
    14881499                {
    14891500                    fSchemaValidator->emitError(XMLValid::ElementNotValidForContent, elemDecl.getFullName(), elemDecl.getFormattedContentModel());
    1490                 }
    1491 
    1492                 isSpecified = fSchemaValidator->getIsElemSpecified();
     1501                    error = true;
     1502                }
     1503                else if (unlikely(fSchemaValidator->getErrorOccurred()))
     1504                {
     1505                    error = true;
     1506                }
     1507                else if (unlikely(fSchemaValidator->getIsElemSpecified()))
     1508                {                   
     1509                    fPSVIElemContext.fNormalizedValue = ((SchemaElementDecl &)elemDecl).getDefaultValue();
     1510
     1511                    // even though this element is empty, if it has a specified content value then it must be transformed into
     1512                    // a start and end tag pair. Ergo, this element is only marked as empty if and only if it has no specified value.
     1513
     1514                    parser.invertEmptyTag();
     1515                    if (doPSVI)
     1516                    {
     1517                        parser.writePartialElementPSVI(NULL, NULL, true);
     1518                    }
     1519                    parser.writeContent(fPSVIElemContext.fNormalizedValue, XMLString::stringLen(fPSVIElemContext.fNormalizedValue), false, true);
     1520                    parser.writeEndTag(elemDecl, elemName, uriId);
     1521                }
     1522
    14931523
    14941524                if (doPSVI)
    14951525                {
    1496                     fPSVIElemContext.fIsSpecified = isSpecified;
    1497                     fPSVIElemContext.fErrorOccurred |= fSchemaValidator->getErrorOccurred();
    1498                     if (likely(elemDecl.isDeclared()))
     1526                    // note that if we're empty, won't be a current DV                   
     1527                    fPSVIElemContext.fIsSpecified = hasSpecifiedValue;
     1528                    fPSVIElemContext.fErrorOccurred = error;
     1529                    endElementPSVI((SchemaElementDecl &)elemDecl, parser);
     1530                }
     1531            }
     1532            else
     1533            {
     1534                fSchemaValidator->resetNillable();
     1535            }
     1536        }
     1537
     1538        // If the elem stack is empty, then it was an empty root
     1539        if (likely(!isRoot))
     1540        {
     1541            // if namespaces exist, then its possible we have multiple grammars. check to see what the previous grammar was.
     1542            if (fDoNamespaces)
     1543            {
     1544                // Restore the grammar
     1545                setCurrentGrammar(fElemStack.getCurrentGrammar());
     1546            }
     1547            // Restore the validation flag
     1548            fValidate = fElemStack.getValidationFlag();
     1549        }
     1550    }
     1551    else // if (!isEmpty)
     1552    {
     1553        if (doPSVI)
     1554        {
     1555            // send a partial element psvi
     1556            XSElementDeclaration * xsElemDecl = 0;
     1557            XSTypeDefinition * typeDef = 0;
     1558            if (likely(elemDecl.isDeclared()))
     1559            {
     1560                xsElemDecl = (XSElementDeclaration*) fModel->getXSObject(&elemDecl);
     1561                if (likely(fValidate))
     1562                {
     1563                    ComplexTypeInfo * const curTypeInfo = fSchemaValidator->getCurrentTypeInfo();
     1564                    if (curTypeInfo)
    14991565                    {
    1500                         fPSVIElemContext.fCurrentTypeInfo = fSchemaValidator->getCurrentTypeInfo();
    1501                         fPSVIElemContext.fCurrentDV = fPSVIElemContext.fCurrentTypeInfo ? 0 : fSchemaValidator->getCurrentDatatypeValidator();
    1502                         fPSVIElemContext.fNormalizedValue = fSchemaValidator->getNormalizedValue();
    1503                         if (fPSVIElemContext.fNormalizedValue && *fPSVIElemContext.fNormalizedValue == 0)
    1504                             fPSVIElemContext.fNormalizedValue = 0;
    1505                         // note that if we're empty, won't be a current DV
    1506                         if (fPSVIElemContext.fCurrentDV && fPSVIElemContext.fCurrentDV->getType() == DatatypeValidator::Union)
     1566                        typeDef = (XSTypeDefinition*) fModel->getXSObject(curTypeInfo);
     1567                    }
     1568                    else
     1569                    {
     1570                        DatatypeValidator * const curDV = fSchemaValidator->getCurrentDatatypeValidator();
     1571                        if (curDV)
    15071572                        {
    1508                             psviMemberType = fValidationContext->getValidatingMemberType();
     1573                            typeDef = (XSTypeDefinition*) fModel->getXSObject(curDV);
    15091574                        }
    15101575                    }
    1511                     if (isSpecified)
    1512                     {
    1513                         fPSVIElemContext.fNormalizedValue = ((SchemaElementDecl &)elemDecl).getDefaultValue();
    1514                     }
    1515                 }
    1516             }
    1517 
    1518 
    1519             fSchemaValidator->resetNillable();
    1520             if (doPSVI)
    1521             {
    1522                 endElementPSVI((SchemaElementDecl &)elemDecl, psviMemberType, parser);
    1523             }
    1524 
    1525             if (unlikely(isSpecified))
    1526             {
    1527                 parser.writeStartTag(elemDecl, elemName, uriId, attributeCount, false);
    1528                 const XMLCh * defaultValue = ((SchemaElementDecl&)elemDecl).getDefaultValue();
    1529                 parser.writeContent(defaultValue, XMLString::stringLen(defaultValue));
    1530                 parser.writeEndTag(elemDecl, elemName, uriId);
    1531             }
    1532             else
    1533             {
    1534                 parser.writeStartTag(elemDecl, elemName, uriId, attributeCount, true);
    1535             }
    1536         }
    1537 
    1538         // If the elem stack is empty, then it was an empty root
    1539         if (likely(!isRoot))
    1540         {
    1541             // if namespaces exist, then its possible we have multiple grammars. check to see what the previous grammar was.
    1542             if (fDoNamespaces)
    1543             {
    1544                 // Restore the grammar
    1545                 setCurrentGrammar(fElemStack.getCurrentGrammar());
    1546             }
    1547             // Restore the validation flag
    1548             fValidate = fElemStack.getValidationFlag();
    1549         }
    1550     }
    1551     else // if (!isEmpty)
    1552     {
    1553         parser.writeStartTag(elemDecl, elemName, uriId, attributeCount, false);
    1554         if (doPSVI && likely(grammarType == Grammar::SchemaGrammarType))
    1555         {
    1556             fErrorStack->push(fPSVIElemContext.fErrorOccurred);
     1576                }
     1577            }
     1578
     1579            // fSchemaValidator->getIsElemSpecified() will always return false until SchemaValidator::checkContent(...) is called.
     1580            parser.writePartialElementPSVI(xsElemDecl, typeDef, false);
    15571581        }
    15581582    }
     
    15671591void IGXMLScanner::validateEndTag
    15681592(
    1569     XMLElementDecl &                elemDecl
    1570     , const QName *                 elemName
    1571     , const unsigned int                        uriId
    1572     , const bool                                        isRoot
    1573     , XMLElementDecl **                         children
    1574     , const XMLSize_t                           childCount
    1575     , const bool                    doPSVI
    1576     , XMLDocumentAccumulator &      parser
     1593    XMLElementDecl &                        elemDecl
     1594    , const QName *                         elemName
     1595    , const unsigned int                    uriId
     1596    , const bool                            isRoot
     1597    , XMLElementDecl **                     children
     1598    , const XMLSize_t                       childCount
     1599    , const bool                            doPSVI
     1600    , bool &                                error
     1601    , XMLDocumentAccumulator &              parser
    15771602)
    15781603{
    1579     DEBUG_GRAMMAR_MESSAGE("validateEndTag(" << elemDecl << ',' << elemName << ',' << uriId << ',' << isRoot << ",...," << childCount << ',' << doPSVI << ')');
    1580 
    1581     // these get initialized below 
    1582     fPSVIElemContext.fErrorOccurred = false;
    1583 
    1584     if (doPSVI && likely(fGrammarType == Grammar::SchemaGrammarType))
     1604    DEBUG_GRAMMAR_MESSAGE("validateEndTag(" << elemDecl << ',' << elemName << ',' << uriId << ',' << isRoot << ',' << childCount << ',' << doPSVI << ')');
     1605
     1606    const Grammar::GrammarType grammarType = fGrammarType;
     1607
     1608    if (likely(grammarType == Grammar::SchemaGrammarType))
    15851609    {
    15861610        // reset error occurred
    1587         fPSVIElemContext.fErrorOccurred = fErrorStack->pop();
    15881611        if (fValidate && elemDecl.isDeclared())
    15891612        {
    15901613            fPSVIElemContext.fCurrentTypeInfo = fSchemaValidator->getCurrentTypeInfo();
    15911614            fPSVIElemContext.fCurrentDV = fPSVIElemContext.fCurrentTypeInfo ? 0 : fSchemaValidator->getCurrentDatatypeValidator();
    1592             if (getPSVIHandler())
    1593             {               
    1594                 fPSVIElemContext.fNormalizedValue = fSchemaValidator->getNormalizedValue();
    1595                 if (fPSVIElemContext.fNormalizedValue && *fPSVIElemContext.fNormalizedValue == 0)
    1596                     fPSVIElemContext.fNormalizedValue = 0;
    1597             }
     1615            fPSVIElemContext.fNormalizedValue = doPSVI ? subsituteEmptyStringWithNull(fSchemaValidator->getNormalizedValue()) : 0;
    15981616        }
    15991617        else
     
    16051623    }
    16061624
    1607     DatatypeValidator* psviMemberType = 0;
    1608     bool writePSVI = 0;
     1625    bool isSpecified = false;
     1626
    16091627    //  If validation is enabled, then lets pass him the list of children and
    16101628    //  this element and let him validate it.
    16111629    if (fValidate)
    1612     {
     1630    {       
    16131631        XMLSize_t failure;
    16141632        if (unlikely(!fValidator->checkContent(&elemDecl, children, childCount, &failure)))
     
    16251643            else if (failure >= childCount)
    16261644            {
    1627                 fValidator->emitError(XMLValid::NotEnoughElemsForCM, elemDecl.getFormattedContentModel());
     1645                fValidator->emitError(XMLValid::NotEnoughElemsForCM, elemDecl.getFormattedContentModel());               
    16281646            }
    16291647            else
     
    16311649                fValidator->emitError(XMLValid::ElementNotValidForContent, children[failure]->getFullName(), elemDecl.getFormattedContentModel());
    16321650            }
    1633         }
    1634 
    1635         const bool isSpecified = fSchemaValidator->getIsElemSpecified();
    1636 
    1637         if (doPSVI && likely(fGrammarType == Grammar::SchemaGrammarType))
    1638         {
     1651            error = true;
     1652        }
     1653
     1654        if (likely(grammarType == Grammar::SchemaGrammarType))
     1655        {           
    16391656            if (fSchemaValidator->getErrorOccurred())
    16401657            {
    1641                 fPSVIElemContext.fErrorOccurred = true;
    1642             }
    1643             else if (getPSVIHandler())
    1644             {
    1645                 if (fPSVIElemContext.fCurrentDV && fPSVIElemContext.fCurrentDV->getType() == DatatypeValidator::Union)
    1646                     psviMemberType = fValidationContext->getValidatingMemberType();
    1647             }
    1648 
    1649             fPSVIElemContext.fIsSpecified = isSpecified;
    1650             if (isSpecified)
    1651             {
    1652                 fPSVIElemContext.fNormalizedValue = ((SchemaElementDecl &)elemDecl).getDefaultValue();
    1653             }
    1654 
    1655             writePSVI = true;
    1656         }
    1657 
     1658                error = true;
     1659            }
     1660            else
     1661            {
     1662                if (unlikely(fSchemaValidator->getIsElemSpecified()))
     1663                {
     1664                    const XMLCh * defaultValue = ((SchemaElementDecl&)elemDecl).getDefaultValue();
     1665                    fPSVIElemContext.fNormalizedValue = ((SchemaElementDecl &)elemDecl).getDefaultValue();
     1666                    parser.writeContent(defaultValue, XMLString::stringLen(defaultValue));
     1667                    isSpecified = true;
     1668                }
     1669            }
     1670        }
     1671    }
     1672    else if (grammarType == Grammar::SchemaGrammarType)
     1673    {
    16581674        fSchemaValidator->resetNillable();
    1659 
    1660         if (isSpecified)
    1661         {
    1662             const XMLCh * defaultValue = ((SchemaElementDecl&)elemDecl).getDefaultValue();
    1663             parser.writeContent(defaultValue, XMLString::stringLen(defaultValue));
    1664         }
    1665     }   
    1666 
    1667     if (writePSVI)
    1668     {
    1669         endElementPSVI((SchemaElementDecl&)elemDecl, psviMemberType, parser);
    1670     }
     1675    }
     1676
    16711677    parser.writeEndTag(elemDecl, elemName, uriId);
    16721678
     
    16741680    fElemStack.popTop();
    16751681
     1682    if (grammarType == Grammar::SchemaGrammarType)
     1683    {
     1684        if (doPSVI)
     1685        {
     1686            fPSVIElemContext.fIsSpecified = isSpecified;
     1687            fPSVIElemContext.fErrorOccurred = error;
     1688            endElementPSVI((SchemaElementDecl&)elemDecl, parser);
     1689        }
     1690        fSchemaValidator->clearDatatypeBuffer();
     1691    }
     1692
    16761693
    16771694    // If this was the root, then done with content
    16781695    if (likely(!isRoot))
    16791696    {
    1680         // if an error occured within a child element, its parent is also in error
    1681         if (doPSVI && unlikely(fPSVIElemContext.fErrorOccurred) && fGrammarType == Grammar::SchemaGrammarType)
    1682         {
    1683             fErrorStack->push(fPSVIElemContext.fErrorOccurred | fErrorStack->pop());
    1684         }
    1685 
    16861697        if (fDoNamespaces)
    16871698        {
     
    17181729        fValidate = fElemStack.getValidationFlag();
    17191730    }
     1731}
     1732
     1733// --------------------------------------------------------------------------------------------------------
     1734// HANDLE SCHEMA WHITESPACE NORMALIZATION
     1735// --------------------------------------------------------------------------------------------------------
     1736
     1737bool IGXMLScanner::doSchemaWhitespaceNormalization
     1738(
     1739    const XMLCh     * &             content
     1740    , XMLSize_t &                   length
     1741)
     1742{
     1743    DatatypeValidator * dv = fSchemaValidator->getCurrentDatatypeValidator();
     1744    bool normalized = false;
     1745    const XMLCh * normalizedContent = content;
     1746    XMLSize_t normalizedLength = length;
     1747    if (dv && dv->getWSFacet() != DatatypeValidator::PRESERVE)
     1748    {
     1749        // normalize the character according to schema whitespace facet
     1750        fSchemaValidator->normalizeWhiteSpace(dv->getWSFacet(), content, fWSNormalizeBuf, length, false);
     1751        normalizedContent = fWSNormalizeBuf.getRawBuffer();
     1752        normalizedLength = fWSNormalizeBuf.getLen();
     1753        normalized = fNormalizeData;
     1754    }
     1755
     1756    // tell the schema validation about the character data for checkContent later
     1757    fSchemaValidator->setDatatypeBuffer(normalizedContent);
     1758
     1759    if (normalized)
     1760    {
     1761        content = normalizedContent;
     1762        length = normalizedLength;
     1763    }
     1764    return normalized;
    17201765}
    17211766
     
    17281773    const XMLCh     *               content
    17291774    , XMLSize_t                     length
    1730     , const bool                    doPSVI   
    17311775    , const XMLContentFlag          flags
     1776    , const bool                    doPSVI
    17321777    , XMLDocumentAccumulator &      parser
    17331778    , const bool                    write
     
    17481793            // And see if the current element is a 'Children' style content model
    17491794            ComplexTypeInfo * currType = fSchemaValidator->getCurrentTypeInfo();
     1795            DEBUG_MESSAGE("currType=" << currType)
    17501796            if (currType)
    17511797            {
     
    17741820            if (length)
    17751821            {
    1776                 XMLSize_t normLength = length;
    1777                 const XMLCh * normContent = content;
    17781822                bool normalized = false;
    1779 
    17801823                if (fGrammarType == Grammar::SchemaGrammarType)
    17811824                {
    1782                     DatatypeValidator * dv = fSchemaValidator->getCurrentDatatypeValidator();
    1783                     if (dv && dv->getWSFacet() != DatatypeValidator::PRESERVE)
    1784                     {
    1785                         // normalize the character according to schema whitespace facet
    1786                         fSchemaValidator->normalizeWhiteSpace(dv->getWSFacet(), content, fWSNormalizeBuf, length, false);
    1787                         normContent = fWSNormalizeBuf.getRawBuffer();
    1788                         normLength = fWSNormalizeBuf.getLen();
    1789                         if (fNormalizeData)
    1790                         {
    1791                             content = normContent;
    1792                             length = normLength;
    1793                             normalized = true;
    1794                         }
    1795                     }
    1796 
    1797                     // tell the schema validation about the character data for checkContent later
    1798                     fSchemaValidator->setDatatypeBuffer(normContent);
    1799 
    1800                     // call all active identity constraints
    1801                     if (toCheckIdentityConstraint() && fICHandler->getMatcherCount())
    1802                     {
    1803                         fContent.append(normContent, normLength);
    1804                     }
    1805                 }
    1806 
    1807                 parser.writeContent(content, length, write | normalized);
     1825                    normalized = doSchemaWhitespaceNormalization(content, length);
     1826                }
     1827                parser.writeContent(content, length, write | normalized, doPSVI);
    18081828            }
    18091829        }
     
    19111931(
    19121932    const XMLCh       *             cdata
    1913     , const XMLSize_t               length
     1933    , XMLSize_t                     length
     1934    , const bool                    doPSVI
    19141935    , XMLDocumentAccumulator &      parser
    19151936)
    19161937{
     1938    bool normalized = false;
    19171939
    19181940    if (fValidate)
     
    19401962            }
    19411963
    1942             // call all active identity constraints
    1943             if (toCheckIdentityConstraint() && fICHandler->getMatcherCount())
    1944             {
    1945                 fContent.append(cdata, length);
    1946             }
     1964            normalized = doSchemaWhitespaceNormalization(cdata, length);
    19471965        }
    19481966        else // if (fGrammarType == Grammar::DTDGrammarType)
     
    19771995    }
    19781996
    1979     // tell the schema validation about the character data for checkContent later
    1980     fPSVIElemContext.fNormalizedValue = cdata;
    1981 
    1982     parser.writeCDATA(cdata, length);
     1997    parser.writeCDATA(cdata, length, normalized, doPSVI);
    19831998}
    19841999
     
    19922007)
    19932008{
    1994     DEBUG_GRAMMAR_MESSAGE("IGXMLScanner::setXsiType(" << prefix << ',' << localPart << ',' << uriId << ')')
    1995 
    19962009        if (fSchemaValidator)
    19972010        {
     2011        if (unlikely(!fValidator->handlesSchema()))
     2012        {
     2013            switchToSchemaGrammar();
     2014        }
     2015
    19982016        fSchemaValidator->setXsiType(prefix, localPart, uriId);
    19992017        }
     
    20092027        if (fSchemaValidator)
    20102028        {
     2029        if (unlikely(!fValidator->handlesSchema()))
     2030        {
     2031            switchToSchemaGrammar();
     2032        }
     2033
    20112034        if (length == 4 && XMLString::equals(value, SchemaSymbols::fgATTVAL_TRUE))
    20122035                {
     
    20352058// ----------------------------------------------------------------------------------------------
    20362059
    2037 void IGXMLScanner::endElementPSVI(SchemaElementDecl & elemDecl, DatatypeValidator * const memberDV, XMLDocumentAccumulator & parser)
     2060void IGXMLScanner::endElementPSVI(SchemaElementDecl & element, XMLDocumentAccumulator & parser)
    20382061{
    20392062    XSTypeDefinition* typeDef = 0;
    2040     bool isMixed = false;
    2041     bool valid = fValidate && !fPSVIElemContext.fErrorOccurred;
     2063    PSVIElement::ASSESSMENT_TYPE assessmentType;
     2064    PSVIElement::VALIDITY_STATE validity = PSVIElement::VALIDITY_NOTKNOWN;
     2065    bool isMixed = false;   
     2066    DatatypeValidator * const currentDV = fPSVIElemContext.fCurrentDV;
     2067    DatatypeValidator * memberDV = 0;
     2068    XSSimpleTypeDefinition * memberType = 0;
     2069
     2070    DEBUG_MESSAGE(" -- currentDV=" << currentDV)
     2071
     2072    // note that if we're empty, won't be a current DV
     2073    if (currentDV && currentDV->getType() == DatatypeValidator::Union)
     2074    {
     2075        memberDV = fValidationContext->getValidatingMemberType();
     2076    }
     2077
     2078    DEBUG_MESSAGE(" -- memberDV=" << memberDV)
     2079
     2080    if (memberDV)
     2081    {
     2082        memberType = (XSSimpleTypeDefinition*)fModel->getXSObject(memberDV);
     2083    }
     2084    else
     2085    {
     2086        memberDV = currentDV;
     2087    }
     2088
     2089    DEBUG_MESSAGE(" -- memberType=" << memberType)
     2090
     2091    if (fPSVIElemContext.fElemDepth > fPSVIElemContext.fFullValidationDepth)
     2092    {
     2093        assessmentType = PSVIElement::VALIDATION_FULL;
     2094    }
     2095    else if (fPSVIElemContext.fElemDepth > fPSVIElemContext.fNoneValidationDepth)
     2096    {
     2097        assessmentType = PSVIElement::VALIDATION_NONE;
     2098    }
     2099    else
     2100    {
     2101        assessmentType  = PSVIElement::VALIDATION_PARTIAL;
     2102        fPSVIElemContext.fFullValidationDepth = fPSVIElemContext.fElemDepth - 1;
     2103        fPSVIElemContext.fNoneValidationDepth = fPSVIElemContext.fElemDepth - 1;
     2104    }
     2105
     2106    fPSVIElemContext.fElemDepth--;
     2107
     2108    XSElementDeclaration * elemDecl = 0;
     2109    if (likely(element.isDeclared()))
     2110    {
     2111        elemDecl = (XSElementDeclaration*) fModel->getXSObject(&element);
     2112        validity = (fPSVIElemContext.fErrorOccurred && fValidate) ? PSVIElement::VALIDITY_INVALID : PSVIElement::VALIDITY_VALID;
     2113    }
    20422114
    20432115    if (fPSVIElemContext.fCurrentTypeInfo)
    20442116    {
    20452117        typeDef = (XSTypeDefinition*) fModel->getXSObject(fPSVIElemContext.fCurrentTypeInfo);
    2046         SchemaElementDecl::ModelTypes modelType = (SchemaElementDecl::ModelTypes)fPSVIElemContext.fCurrentTypeInfo->getContentType();
     2118        SchemaElementDecl::ModelTypes modelType = (SchemaElementDecl::ModelTypes)(fPSVIElemContext.fCurrentTypeInfo->getContentType());
    20472119        isMixed = (modelType == SchemaElementDecl::Mixed_Simple || modelType == SchemaElementDecl::Mixed_Complex);
    20482120    }
    2049     else if (fPSVIElemContext.fCurrentDV)
    2050     {
    2051         typeDef = (XSTypeDefinition*) fModel->getXSObject(fPSVIElemContext.fCurrentDV);
    2052     }
    2053 
     2121    else if (currentDV)
     2122    {
     2123        typeDef = (XSTypeDefinition*) fModel->getXSObject(currentDV);
     2124    }
     2125
     2126    DEBUG_MESSAGE(" -- typeDef=" << typeDef)
     2127
     2128    // TODO: modify all the getCanonicalRepresentation functions so that most of them aren't simply validating and returning a duplicate of the string.
     2129    // NOTE: I ought to insert the appropriate canonical value into the psvi string pool directly if and only if it differs from the normalized value.
    20542130    XMLCh* canonicalValue = 0;
    2055     if (fPSVIElemContext.fNormalizedValue && !isMixed && valid)
    2056     {
    2057         if (memberDV)
    2058             canonicalValue = (XMLCh*) memberDV->getCanonicalRepresentation(fPSVIElemContext.fNormalizedValue, fMemoryManager);
    2059         else if (fPSVIElemContext.fCurrentDV)
    2060             canonicalValue = (XMLCh*) fPSVIElemContext.fCurrentDV->getCanonicalRepresentation(fPSVIElemContext.fNormalizedValue, fMemoryManager);
    2061     }
    2062 
    2063     XSElementDeclaration * elemDeclXS = (elemDecl.isDeclared()) ? (XSElementDeclaration*) fModel->getXSObject(&elemDecl) : 0;
    2064     XSSimpleTypeDefinition * memberDVXS = (memberDV) ? (XSSimpleTypeDefinition*) fModel->getXSObject(memberDV) : 0;
    2065 
    2066     parser.writeElementPSVI(elemDeclXS, typeDef, memberDVXS, fPSVIElemContext.fNormalizedValue, canonicalValue);
     2131    if (fPSVIElemContext.fNormalizedValue && !isMixed && memberDV && validity == PSVIElement::VALIDITY_VALID)
     2132    {
     2133        canonicalValue = (XMLCh*)memberDV->getCanonicalRepresentation(fPSVIElemContext.fNormalizedValue, fMemoryManager);
     2134    }
     2135
     2136    parser.writeElementPSVI(elemDecl, typeDef, memberType, fPSVIElemContext.fNormalizedValue, canonicalValue, validity, assessmentType, fPSVIElemContext.fIsSpecified);
     2137
     2138    if (canonicalValue)
     2139    {
     2140        XMLString::release(&canonicalValue, fMemoryManager);
     2141    }
    20672142}
    20682143
     
    20922167    unsigned int currLoop = fElemLoopState[parentElemDepth];
    20932168
    2094     SubstitutionGroupComparator comparator(fGrammarResolver, fUriResolver);
     2169    SubstitutionGroupComparator comparator(fGrammarResolver, fNamespaceResolver);
    20952170
    20962171    XMLSize_t i = 0;
     
    21062181        if (type == ContentSpecNode::Leaf)
    21072182        {
    2108             if (((mappedUriId == elementUriId) && XMLString::equals(fElemMap->getLocalPart(), element->getLocalPart())) || comparator.isEquivalentTo(element, fElemMap))
     2183            if (((mappedUriId == elementUriId) && (fElemMap->getLocalPart() == element->getLocalPart())) || comparator.isEquivalentTo(element, fElemMap))
    21092184            {
    21102185                nextState = cm->getNextState(currState, i);
  • icXML/icXML-devel/src/icxercesc/internal/IGXMLScanner2.cpp

    r3157 r3564  
    7373
    7474        // fModel may need updating, as fGrammarResolver could have cleaned it
    75         if (fModel && getPSVIHandler())
    76         {
    77                 fModel = fGrammarResolver->getXSModel();
    78         }
    79 
    80         do
     75    if (getPSVIHandler())
     76        {
     77        fModel = fGrammarResolver->getXSModel();
     78    }
     79
    8180        {
    8281                XMLDTDDescriptionImpl theDTDDescription(XMLUni::fgDTDEntityString, fMemoryManager);
    8382                fDTDGrammar = (DTDGrammar*) fGrammarResolver->getGrammar(&theDTDDescription);
    84         } while (0);
     83    }
    8584
    8685        if (!fDTDGrammar)
     
    152151        if (!fPSVIElement)
    153152                fPSVIElement = new (fMemoryManager) PSVIElement(fMemoryManager);
    154 
    155         if (!fErrorStack)
    156         {
    157                 fErrorStack = new (fMemoryManager) ValueStackOf<bool>(8, fMemoryManager);
    158         }
    159         else
    160         {
    161                 fErrorStack->removeAllElements();
    162         }
    163153
    164154        resetPSVIElemContext();
     
    268258                if (fLoadSchema || ignoreLoadSchema)
    269259                {
    270                         XSDDOMParser parser(0, fMemoryManager, 0);
    271                         parser.getScanner()->setUriResolver(getUriResolver());
     260            XSDDOMParser parser(0, fMemoryManager, fGrammarResolver->getGrammarPool());
    272261                        parser.setValidationScheme(XercesDOMParser::Val_Never);
    273262                        parser.setDoNamespaces(true);
     
    354343                        //
    355344                        const XMLCh* sysId = srcToFill->getSystemId();
    356                         unsigned int uriId = fUriResolver->resolveUriId(uri);
     345            unsigned int uriId = fNamespaceResolver->resolveUriId(uri);
    357346                        SchemaInfo* importSchemaInfo = 0;
    358347
     
    417406                                                        if (fUseCachedGrammar)
    418407                                                        {
    419                                 importSchemaInfo = fCachedSchemaInfoList->get(sysId, fUriResolver->resolveUriId(newUri));
     408                                importSchemaInfo = fCachedSchemaInfoList->get(sysId, fNamespaceResolver->resolveUriId(newUri));
    420409                                                        }
    421410                                                        if (!importSchemaInfo && !fToCacheGrammar)
    422411                            {
    423                                 importSchemaInfo = fSchemaInfoList->get(sysId, fUriResolver->resolveUriId(newUri));
     412                                importSchemaInfo = fSchemaInfoList->get(sysId, fNamespaceResolver->resolveUriId(newUri));
    424413                            }
    425414                                                        if (importSchemaInfo)
     
    463452                                                else
    464453                                                {
    465                                                         assert (fGrammarPoolMemoryManager != NULL);
    466                                                         schemaGrammar = new (fGrammarPoolMemoryManager) SchemaGrammar(fGrammarPoolMemoryManager);
     454                            schemaGrammar = fGrammarResolver->getGrammarPool()->createSchemaGrammar();
    467455                                                }
    468456
     
    492480                                                );
    493481
     482                        DEBUG_GRAMMAR_MESSAGE("######################################################################");
     483
    494484                                                // Reset the now invalid schema roots in the collected
    495485                                                // schema info entries.
     
    558548        if (getPSVIHandler())
    559549        {
    560                 fModel = fGrammarResolver->getXSModel();
    561         }
     550        fModel = fGrammarResolver->getXSModel();
     551    }
    562552}
    563553
     
    642632//  IGXMLScanner: Private grammar preparsing methods
    643633// ---------------------------------------------------------------------------
    644 Grammar* IGXMLScanner::loadXMLSchemaGrammar(const InputSource& src,
    645                                                                                         const bool toCache)
     634Grammar* IGXMLScanner::loadXMLSchemaGrammar
     635(
     636    const InputSource&      src
     637    , const bool            toCache
     638)
    646639{
    647640        // Reset the validators
     
    664657        }
    665658
    666         XSDDOMParser parser(0, fMemoryManager, 0);
     659    XSDDOMParser parser(0, fMemoryManager, fGrammarResolver->getGrammarPool());
    667660
    668661        parser.setValidationScheme(XercesDOMParser::Val_Never);
     
    700693                        if (grammar)
    701694                        {
     695                unsigned int uriId;
     696
    702697                                if (nsUri && *nsUri)
    703                                         importSchemaInfo = fCachedSchemaInfoList->get(sysId, fUriResolver->resolveUriId(nsUri));
     698                {
     699                    uriId = fNamespaceResolver->resolveUriId(nsUri);
     700                }
    704701                                else
    705                     importSchemaInfo = fCachedSchemaInfoList->get(sysId, fUriResolver->getUriIdForPrefix(XMLNamespaceResolver::fEmptyUriId, fContextId));
     702                {
     703                    uriId = fNamespaceResolver->getUriIdForPrefix(XMLNamespaceResolver::fEmptyUriId, *fNamespaceContextId);
     704                }
     705                importSchemaInfo = fCachedSchemaInfoList->get(sysId, uriId);
    706706                        }
    707707
     
    769769                        if (getPSVIHandler())
    770770                        {
    771                                 fModel = fGrammarResolver->getXSModel();
    772                         }
     771                fModel = fGrammarResolver->getXSModel();
     772            }
    773773                        return grammar;
    774774                }
     
    787787// if skip - no validation
    788788// if lax - validate only if the attribute if found
    789 bool IGXMLScanner::anyAttributeValidation(SchemaAttDef* attWildCard, unsigned int uriId, bool & skipThisOne, bool & laxThisOne)
     789bool IGXMLScanner::anyAttributeValidation(SchemaAttDef* attWildCard, unsigned int uriId, bool & skipThisOne, bool & laxValidation)
    790790{
    791791        XMLAttDef::AttTypes wildCardType = attWildCard->getType();
    792792        bool anyEncountered = false;
    793793        skipThisOne = false;
    794         laxThisOne = false;
     794    laxValidation = false;
    795795        if (wildCardType == XMLAttDef::Any_Any)
    796796        {
     
    827827                else if (defType == XMLAttDef::ProcessContents_Lax)
    828828                {
    829                         laxThisOne = true;
     829            laxValidation = true;
    830830                }
    831831        }
  • icXML/icXML-devel/src/icxercesc/internal/MemoryManagerImpl.cpp

    r3178 r3564  
    2626#include <icxercesc/internal/MemoryManagerImpl.hpp>
    2727#include <xercesc/util/OutOfMemoryException.hpp>
     28#include <icxmlc/XMLConfig.hpp>
    2829
    2930XERCES_CPP_NAMESPACE_BEGIN
     
    3637void* MemoryManagerImpl::allocate(XMLSize_t size)
    3738{
     39    assert (((ssize_t)size) > 0);
     40
    3841    void* memptr;
    39     try {
     42    try
     43    {
    4044        memptr = ::operator new(size);
    4145    }
    42     catch(...) {
     46    catch(...)
     47    {
    4348        throw OutOfMemoryException();
    4449    }
    45     if (memptr != NULL) {
    46         return memptr;
     50    if (unlikely(memptr == NULL && size!=0))
     51    {
     52        throw OutOfMemoryException();
    4753    }
    48     throw OutOfMemoryException();
     54    return memptr;
    4955}
    5056
  • icXML/icXML-devel/src/icxercesc/internal/ReaderMgr.cpp

    r3150 r3564  
    398398        // We need to handle this exception to avoid leak on newStream.
    399399
     400    const XMLCh* encoding = src.getEncoding();
     401    if (encoding == 0)
     402    {
     403        encoding = newStream->getEncoding();
     404    }
     405
    400406        try
    401407        {
    402                 if (src.getEncoding())
     408        if (encoding)
    403409                {
    404410                        retVal = new (fMemoryManager) XMLReader
     
    407413                                , src.getSystemId()
    408414                                , newStream
    409                                 , src.getEncoding()
     415                , encoding
    410416                                , refFrom
    411417                                , type
     
    823829}
    824830
    825 void ReaderMgr::getLastExtEntityInfo(LastExtEntityInfo& lastInfo) const
    826 {
    827         //
    828         //  If the reader stack never got created or we've not managed to open any
    829         //  main entity yet, then we can't give this information.
    830         //
    831     if (!fCurReader)
    832         {
    833                 lastInfo.systemId = XMLUni::fgZeroLenString;
    834                 lastInfo.publicId = XMLUni::fgZeroLenString;
    835                 lastInfo.lineNumber = 0;
    836                 lastInfo.colNumber = 0;
    837                 return;
    838         }
    839 
    840         // We have at least one entity so get the data
    841         const XMLEntityDecl*    theEntity;
    842         const XMLReader*        theReader = getLastExtEntity(theEntity);
    843 
    844         // Fill in the info structure with the reader we found
    845         lastInfo.systemId = theReader->getSystemId();
    846         lastInfo.publicId = theReader->getPublicId();
    847         theReader->getCurrentLineColumn(lastInfo.lineNumber, lastInfo.colNumber);
    848 }
    849 
    850 
    851831bool ReaderMgr::isScanningPERefOutOfLiteral() const
    852832{
     
    955935}
    956936
    957 
    958937// ---------------------------------------------------------------------------
    959938//  ReaderMgr: Implement the SAX Locator interface
    960939// ---------------------------------------------------------------------------
     940void ReaderMgr::getLocationInfo(Locator::LocationInfo & locationInfo) const
     941{
     942    //
     943    //  If the reader stack never got created or we've not managed to open any
     944    //  main entity yet, then we can't give this information.
     945    //
     946    if (!fCurReader)
     947    {
     948        locationInfo.systemId = XMLUni::fgZeroLenString;
     949        locationInfo.publicId = XMLUni::fgZeroLenString;
     950        locationInfo.lineNumber = 0;
     951        locationInfo.colNumber = 0;
     952        return;
     953    }
     954
     955    // We have at least one entity so get the data
     956    const XMLEntityDecl*    theEntity;
     957    const XMLReader*        theReader = getLastExtEntity(theEntity);
     958
     959    // Fill in the info structure with the reader we found
     960    locationInfo.systemId = theReader->getSystemId();
     961    locationInfo.publicId = theReader->getPublicId();
     962    theReader->getCurrentLineColumn(locationInfo.lineNumber, locationInfo.colNumber);
     963}
     964
     965
    961966const XMLCh* ReaderMgr::getPublicId() const
    962967{
    963968        if (!fReaderStack && !fCurReader)
    964969                return XMLUni::fgZeroLenString;
    965 
    966970        const XMLEntityDecl* theEntity;
    967971        return getLastExtEntity(theEntity)->getPublicId();
     
    972976        if (!fReaderStack && !fCurReader)
    973977                return XMLUni::fgZeroLenString;
    974 
    975978        const XMLEntityDecl* theEntity;
    976979        return getLastExtEntity(theEntity)->getSystemId();
     
    981984        if (!fReaderStack && !fCurReader)
    982985                return 0;
    983 
    984     //const XMLEntityDecl* theEntity;
    985     return 1; // getLastExtEntity(theEntity)->getColumnNumber();
     986    const XMLEntityDecl* theEntity;
     987    return getLastExtEntity(theEntity)->getColumnNumber();
    986988}
    987989
     
    990992        if (!fReaderStack && !fCurReader)
    991993                return 0;
    992 
    993     //const XMLEntityDecl* theEntity;
    994     return 2; // getLastExtEntity(theEntity)->getLineNumber();
     994    const XMLEntityDecl* theEntity;
     995    return getLastExtEntity(theEntity)->getLineNumber();
    995996}
    996997
  • icXML/icXML-devel/src/icxercesc/internal/ReaderMgr.hpp

    r3150 r3564  
    3131XERCES_CPP_NAMESPACE_BEGIN
    3232
    33 #if 1
    34 
    3533class XMLEntityDecl;
    3634class XMLEntityHandler;
     
    6159        //  Class specific types
    6260        // -----------------------------------------------------------------------
    63         struct LastExtEntityInfo : public XMemory
    64         {
    65                 const   XMLCh*          systemId;
    66                 const   XMLCh*          publicId;
    67                                 XMLFileLoc      lineNumber;
    68                                 XMLFileLoc      colNumber;
    69         };
    70 
     61    typedef Locator::LocationInfo LastExtEntityInfo;
     62
     63//      struct LastExtEntityInfo : public XMemory
     64//      {
     65//              const   XMLCh*          systemId;
     66//              const   XMLCh*          publicId;
     67//                              XMLFileLoc      lineNumber;
     68//                              XMLFileLoc      colNumber;
     69//      };
    7170
    7271        // -----------------------------------------------------------------------
     
    200199        virtual const XMLCh* getSystemId() const;
    201200        virtual XMLFileLoc getLineNumber() const;
    202         virtual XMLFileLoc getColumnNumber() const;
     201        virtual XMLFileLoc getColumnNumber() const;   
     202    virtual void getLocationInfo(Locator::LocationInfo & locationInfo) const;
    203203
    204204
     
    311311inline const XMLReader* ReaderMgr::getCurrentReader() const
    312312{
    313         assert (fCurReader != NULL);
    314313        return fCurReader;
    315314}
     
    317316inline XMLReader* ReaderMgr::getCurrentReader()
    318317{
    319         assert (fCurReader != NULL);
    320318        return fCurReader;
    321319}
     
    397395                // Get chars until we find the one to skip
    398396                nextCh = getNextChar();
    399                 }
    400         // Break out at end of input or the char to skip
    401                 while((nextCh != toSkipTo) && nextCh!=0);
     397    }
     398    while((nextCh != toSkipTo) && nextCh!=0);
     399
     400        // Break out at end of input or the char to skip       
    402401}
    403402
     
    429428}
    430429
    431 #endif
     430
     431inline void ReaderMgr::getLastExtEntityInfo(LastExtEntityInfo& lastInfo) const
     432{
     433    return getLocationInfo(lastInfo);
     434}
    432435
    433436//
  • icXML/icXML-devel/src/icxercesc/internal/SGXMLScanner.cpp

    r3157 r3564  
    6767SGXMLScanner::SGXMLScanner( XMLValidator* const valToAdopt
    6868                                                  , GrammarResolver* const grammarResolver
    69                                                   , MemoryManager* const manager) :
    70 
    71         XMLScanner(valToAdopt, grammarResolver, manager)
    72         , fSeeXsi(false)
    73         , fGrammarType(Grammar::UnKnown)
    74         , fElemStateSize(16)
    75         , fElemState(0)
    76         , fElemLoopState(0)
    77         , fContent(1023, manager)
    78         , fEntityTable(0)
    79         , fRawAttrList(0)
    80         , fRawAttrColonListSize(32)
    81         , fRawAttrColonList(0)
    82         , fSchemaGrammar(0)
    83         , fSchemaValidator(0)
    84         , fICHandler(0)
    85         , fElemNonDeclPool(0)
    86         , fElemCount(0)
    87         , fAttDefRegistry(0)
    88         , fUndeclaredAttrRegistry(0)
    89         , fPSVIAttrList(0)
    90         , fModel(0)
    91         , fPSVIElement(0)
    92         , fErrorStack(0)
    93         , fSchemaInfoList(0)
    94         , fCachedSchemaInfoList(0)
    95 #ifdef MOVE_BUFFERS_OUT_OF_XMLSCANNER
    96         , fAttNameBuf(1023, manager)
    97         , fAttValueBuf(1023, manager)
    98         , fCDataBuf(1023, manager)
    99         , fQNameBuf(1023, manager)
    100         , fPrefixBuf(1023, manager)
    101         , fURIBuf(1023, manager)
    102         , fWSNormalizeBuf(1023, manager)
    103 #endif
     69                          , MemoryManager* const manager)
     70: XMLScanner(valToAdopt, grammarResolver, manager)
     71, fSeeXsi(false)
     72, fGrammarType(Grammar::UnKnown)
     73, fElemStateSize(16)
     74, fElemState(0)
     75, fElemLoopState(0)
     76, fContent(1023, manager)
     77, fEntityTable(0)
     78, fRawAttrList(0)
     79, fRawAttrColonListSize(32)
     80, fRawAttrColonList(0)
     81, fSchemaGrammar(0)
     82, fSchemaValidator(0)
     83, fICHandler(0)
     84, fElemNonDeclPool(0)
     85, fElemCount(0)
     86, fAttDefRegistry(0)
     87, fUndeclaredAttrRegistry(0)
     88, fPSVIAttrList(0)
     89, fModel(0)
     90, fPSVIElement(0)
     91, fErrorStack(0)
     92, fSchemaInfoList(0)
     93, fCachedSchemaInfoList(0)
     94, fAttNameBuf(1023, manager)
     95, fAttValueBuf(1023, manager)
     96, fCDataBuf(1023, manager)
     97, fQNameBuf(1023, manager)
     98, fPrefixBuf(1023, manager)
     99, fURIBuf(1023, manager)
     100, fWSNormalizeBuf(1023, manager)
    104101{
    105102        CleanupType cleanup(this, &SGXMLScanner::cleanUp);
     
    20552052void SGXMLScanner::commonInit()
    20562053{
    2057 #ifdef SGXML_SCANNER_DEPRECATED
    20582054        DEPRECATED_FEATURE_IN_ICXML;
    2059 #else
    2060         //  Create the element state array
    2061         fElemState = (unsigned int*) fMemoryManager->allocate
    2062         (
    2063                 fElemStateSize * sizeof(unsigned int)
    2064         ); //new unsigned int[fElemStateSize];
    2065         fElemLoopState = (unsigned int*) fMemoryManager->allocate
    2066         (
    2067                 fElemStateSize * sizeof(unsigned int)
    2068         ); //new unsigned int[fElemStateSize];
    2069 
    2070         //  And we need one for the raw attribute scan. This just stores key/
    2071         //  value string pairs (prior to any processing.)
    2072         fRawAttrList = new (fMemoryManager) RefVectorOf<KVStringPair>(32, true, fMemoryManager);
    2073         fRawAttrColonList = (int*) fMemoryManager->allocate
    2074         (
    2075                 fRawAttrColonListSize * sizeof(int)
    2076         );
    2077 
    2078         //  Create the Validator and init them
    2079         fSchemaValidator = new (fMemoryManager) SchemaValidator(0, fMemoryManager);
    2080         initValidator(fSchemaValidator);
    2081 
    2082         // Create IdentityConstraint info
    2083         fICHandler = new (fMemoryManager) IdentityConstraintHandler(this, fMemoryManager);
    2084 
    2085         //  Add the default entity entries for the character refs that must always
    2086         //  be present.
    2087         fEntityTable = new (fMemoryManager) ValueHashTableOf<XMLCh>(11, fMemoryManager);
    2088         fEntityTable->put((void*) XMLUni::fgAmp, chAmpersand);
    2089         fEntityTable->put((void*) XMLUni::fgLT, chOpenAngle);
    2090         fEntityTable->put((void*) XMLUni::fgGT, chCloseAngle);
    2091         fEntityTable->put((void*) XMLUni::fgQuot, chDoubleQuote);
    2092         fEntityTable->put((void*) XMLUni::fgApos, chSingleQuote);
    2093         fElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager);
    2094         fAttDefRegistry = new (fMemoryManager) RefHashTableOf<unsigned int, PtrHasher>
    2095         (
    2096                 131, false, fMemoryManager
    2097         );
    2098         fUndeclaredAttrRegistry = new (fMemoryManager) Hash2KeysSetOf<StringHasher>(7, fMemoryManager);
    2099         fPSVIAttrList = new (fMemoryManager) PSVIAttributeList(fMemoryManager);
    2100 
    2101         fSchemaInfoList = new (fMemoryManager) RefHash2KeysTableOf<SchemaInfo>(29, fMemoryManager);
    2102         fCachedSchemaInfoList = new (fMemoryManager) RefHash2KeysTableOf<SchemaInfo>(29, fMemoryManager);
    2103 
    2104         if (fValidator)
    2105         {
    2106                 if (!fValidator->handlesSchema())
    2107                         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Gen_NoSchemaValidator, fMemoryManager);
    2108         }
    2109         else
    2110         {
    2111                 fValidator = fSchemaValidator;
    2112         }
    2113 #endif
    21142055}
     2056
     2057void SGXMLScanner::setLocator(Locator *)
     2058{
     2059    /* do nothing */
     2060}
     2061
    21152062
    21162063void SGXMLScanner::cleanUp()
  • icXML/icXML-devel/src/icxercesc/internal/SGXMLScanner.hpp

    r3153 r3564  
    108108        const XMLCh       *             content
    109109        , const XMLSize_t               contentLength
     110        , const XMLContentFlag          flags
    110111        , const bool                    doPSVI
    111         , const XMLContentFlag          flags
    112112        , XMLDocumentAccumulator &      parser
    113113        , const bool                    forceWrite = false
     
    122122        const XMLCh       *             cdata
    123123        , const XMLSize_t               length
     124        , const bool                    doPSVI
    124125        , XMLDocumentAccumulator &      parser
    125126    )
     
    132133    (
    133134        XMLSymbol &                     element
    134         , const QName *                 elemName
    135135        , const unsigned int            uriId
    136         , const bool                                    isRoot
     136        , const bool                    isRoot       
    137137        , const bool                    doPSVI
     138        , bool &                        hasIdentityConstraint
     139        , const bool                    error
    138140        , XMLDocumentAccumulator &      parser
    139141    )
     
    150152        , const XMLSymbol &             attribute
    151153        , const unsigned int            uriId
     154        , const unsigned int            namespaceContextId
    152155        , const XMLCh *                 value
    153156        , const XMLSize_t               length
    154157        , const MarkupType              type
    155158        , const Grammar::GrammarType    grammarType
    156         , const bool                    error
    157159        , const bool                    doPSVI
     160        , bool &                        error
    158161        , XMLDocumentAccumulator &      parser
    159         , const bool                    write
     162        , const bool                    write = false
    160163    )
    161164    {
     
    171174        , const XMLSize_t                               attributeCount
    172175        , const unsigned int            uriId
     176        , const unsigned int            namespaceContextId
    173177        , const bool                                    isRoot
    174178        , const bool                                    isEmpty
    175179        , const Grammar::GrammarType    grammarType
    176180        , const bool                    doPSVI
     181        , bool &                        error
    177182        , XMLDocumentAccumulator &      parser
    178183    )
     
    184189    void validateEndTag
    185190    (
    186         XMLElementDecl &                element
    187         , const QName *                 elemName
    188         , const unsigned int                    uriId
    189         , const bool                                    isRoot
    190         , XMLElementDecl **                             children
    191         , const XMLSize_t                               childCount
    192         , const bool                    doPSVI
    193         , XMLDocumentAccumulator &      parser
     191        XMLElementDecl &                    element
     192        , const QName *                     elemName
     193        , const unsigned int                uriId
     194        , const bool                        isRoot
     195        , XMLElementDecl **                 children
     196        , const XMLSize_t                   childCount
     197        , const bool                        doPSVI
     198        , bool &                            error
     199        , XMLDocumentAccumulator &          parser
    194200    )
    195201    {
     
    307313    RefHash2KeysTableOf<SchemaInfo>*        fSchemaInfoList;
    308314    RefHash2KeysTableOf<SchemaInfo>*        fCachedSchemaInfoList;
    309 
    310 #ifdef MOVE_BUFFERS_OUT_OF_XMLSCANNER
    311     XMLBuffer                   fAttNameBuf;
    312     XMLBuffer                   fAttValueBuf;
    313     XMLBuffer                   fCDataBuf;
    314     XMLBuffer                   fQNameBuf;
    315     XMLBuffer                   fPrefixBuf;
    316     XMLBuffer                   fURIBuf;
    317     XMLBuffer                   fWSNormalizeBuf;
    318 #endif
     315    XMLBuffer                               fAttNameBuf;
     316    XMLBuffer                               fAttValueBuf;
     317    XMLBuffer                               fCDataBuf;
     318    XMLBuffer                               fQNameBuf;
     319    XMLBuffer                               fPrefixBuf;
     320    XMLBuffer                               fURIBuf;
     321    XMLBuffer                               fWSNormalizeBuf;
    319322
    320323private :
     
    347350    // -----------------------------------------------------------------------
    348351    void commonInit();
     352    void setLocator(Locator * locator);
    349353    void cleanUp();
    350354
     
    389393    //  IdentityConstraints Activation methods
    390394    // -----------------------------------------------------------------------
    391     inline bool toCheckIdentityConstraint()  const;
     395    inline bool toCheckIdentityConstraint() const;
    392396
    393397    // -----------------------------------------------------------------------
  • icXML/icXML-devel/src/icxercesc/internal/ValidationContextImpl.cpp

    r3153 r3564  
    2828#include <icxercesc/validators/DTD/DTDEntityDecl.hpp>
    2929#include <xercesc/validators/datatype/InvalidDatatypeValueException.hpp>
    30 #include <icxercesc/validators/schema/NamespaceScope.hpp>
    31 #include <icxercesc/internal/ElemStack.hpp>
    3230#include <icxercesc/internal/XMLScanner.hpp>
     31#include <icxmlc/XMLNamespaceResolver.hpp>
    3332
    3433XERCES_CPP_NAMESPACE_BEGIN
     
    3837// ---------------------------------------------------------------------------
    3938
     39ValidationContextImpl::ValidationContextImpl(MemoryManager* const manager)
     40: ValidationContext(manager)
     41, fIdRefList(new (fMemoryManager) RefHashTableOf<XMLRefInfo>(109, fMemoryManager))
     42, fEntityDeclPool(0)
     43, fToCheckIdRefList(true)
     44, fNamespaceResolver(0)
     45, fNamespaceContextId(0)
     46, fValidatingMemberType(0)
     47{
     48
     49}
     50
    4051ValidationContextImpl::~ValidationContextImpl()
    4152{
    42         if (fIdRefList)
    43                 delete fIdRefList;
    44 }
    45 
    46 ValidationContextImpl::ValidationContextImpl(MemoryManager* const manager)
    47 :ValidationContext(manager)
    48 ,fIdRefList(0)
    49 ,fEntityDeclPool(0)
    50 ,fToCheckIdRefList(true)
    51 ,fValidatingMemberType(0)
    52 ,fScanner(0)
    53 ,fNamespaceScope(0)
    54 {
    55         fIdRefList = new (fMemoryManager) RefHashTableOf<XMLRefInfo>(109, fMemoryManager);
     53    delete fIdRefList;
    5654}
    5755
     
    8987        if (idEntry)
    9088        {
    91                 if (idEntry->getDeclared())
     89        if (unlikely(idEntry->getDeclared()))
    9290                {
    93                         ThrowXMLwithMemMgr1(InvalidDatatypeValueException
    94                                         , XMLExcepts::VALUE_ID_Not_Unique
    95                                         , content
    96                                         , fMemoryManager);
     91                        ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_ID_Not_Unique, content, fMemoryManager);
    9792                }
    9893        }
     
    184179/* QName
    185180 */
    186 bool ValidationContextImpl::isPrefixUnknown(XMLCh* prefix)
     181bool ValidationContextImpl::isPrefixUnknown(XMLCh * prefix)
    187182{
    188     DEBUG_GRAMMAR_MESSAGE("ValidationContextImpl::isPrefixUnknown("  << prefix << ")");
    189 
    190     bool unknown = false;
    191 
    192         if (XMLString::equals(prefix, XMLUni::fgXMLNSString))
    193         {
    194                 return true;
    195         }
    196         else if (!XMLString::equals(prefix, XMLUni::fgXMLString))
    197         {
    198         DEBUG_GRAMMAR_MESSAGE("fNamespaceScope=" << (fNamespaceScope != 0));
    199 
    200                 if (fNamespaceScope)
    201                 {
    202                         unknown = (fNamespaceScope->getNamespaceForPrefix(prefix) == fNamespaceScope->getEmptyNamespaceId());
    203                 }
    204                 else
    205                 {
    206                         unknown = !fScanner->isPrefixKnown(prefix);
    207                 }
    208         }
    209 
    210     DEBUG_GRAMMAR_MESSAGE("unknown="  << unknown);
    211 
    212     return unknown;
     183    // why is the xmlns namespace always unknown? look into the QNameDatatypeValidator specification.
     184    if (unlikely(XMLString::equals(prefix, XMLUni::fgXMLNSString)))
     185    {
     186        return true;
     187    }
     188    return !fNamespaceResolver->isPrefixVisible(prefix, *fNamespaceContextId);
    213189}
    214190
    215191const XMLCh* ValidationContextImpl::getURIForPrefix(XMLCh* prefix)
    216192{
    217         if (fNamespaceScope)
    218         {
    219                 unsigned int uriId = fNamespaceScope->getNamespaceForPrefix(prefix);
    220                 if (uriId != fNamespaceScope->getEmptyNamespaceId())
    221                 {
    222                         return fScanner->getURIText(uriId);
    223                 }
    224                 return XMLUni::fgZeroLenString;
    225         }
    226         else
    227         {
    228                 return fScanner->getURIForPrefix(prefix);
    229         }
    230 
     193    return fNamespaceResolver->getUriForPrefix(prefix, *fNamespaceContextId);
    231194}
    232195
  • icXML/icXML-devel/src/icxercesc/internal/ValidationContextImpl.hpp

    r2720 r3564  
    1818
    1919XERCES_CPP_NAMESPACE_BEGIN
     20
    2021class ElemStack;
    2122class NamespaceScope;
     23class XMLScanner;
     24class XMLNamespaceResolver;
    2225
    2326class XMLPARSER_EXPORT ValidationContextImpl : public ValidationContext
     
    3538        virtual ~ValidationContextImpl();
    3639
    37         ValidationContextImpl(MemoryManager* const memMgr = XMLPlatformUtils::fgMemoryManager);
     40        //@}
    3841
    39         //@}
     42    ValidationContextImpl(MemoryManager* const memMgr = XMLPlatformUtils::fgMemoryManager);
    4043
    4144        // -----------------------------------------------------------------------
     
    8689        virtual void setElemStack(ElemStack* elemStack);
    8790        virtual const XMLCh* getURIForPrefix(XMLCh* prefix);
     91
    8892        virtual void setScanner(XMLScanner* scanner);
    8993        virtual void setNamespaceScope(NamespaceScope* nsStack);
    9094
     95    void initNamespaceContext(const XMLNamespaceResolver * namespaceResolver, unsigned int * namespaceContextId);
    9196
    9297        //@}
     
    120125        //      will not be accurate unless the type of the most recently-validated
    121126        //      element/attribute is in fact a union datatype.
    122         //  fNamespaceScope
    123         //      Need access to namespace scope to look up URI's that are inscope (while loading a schema).
    124127        // -----------------------------------------------------------------------
    125128
     
    127130        const NameIdPool<DTDEntityDecl>*    fEntityDeclPool;
    128131        bool                                fToCheckIdRefList;
    129         DatatypeValidator *                 fValidatingMemberType;
    130         XMLScanner*                         fScanner;
    131         NamespaceScope*                     fNamespaceScope;
     132    // given that it's highly unlikely we'll need to test the namespace context id, just store a pointer to the integer
     133    const XMLNamespaceResolver *        fNamespaceResolver;
     134    unsigned int *                      fNamespaceContextId;
     135    DatatypeValidator *                 fValidatingMemberType;
    132136};
    133 
    134 
    135137
    136138inline DatatypeValidator * ValidationContextImpl::getValidatingMemberType() const
    137139{
    138         return fValidatingMemberType;
     140    return fValidatingMemberType;
    139141}
    140142
    141 inline void ValidationContextImpl::setValidatingMemberType(DatatypeValidator * validatingMemberType)
     143inline void ValidationContextImpl::setValidatingMemberType(DatatypeValidator * dv)
    142144{
    143         fValidatingMemberType = validatingMemberType;
     145    fValidatingMemberType = dv;
     146}
     147
     148inline void ValidationContextImpl::initNamespaceContext(const XMLNamespaceResolver * namespaceResolver, unsigned int * namespaceContextId)
     149{
     150    fNamespaceResolver = namespaceResolver;
     151    fNamespaceContextId = namespaceContextId;
     152}
     153
     154inline void ValidationContextImpl::setScanner(XMLScanner*)
     155{
     156    DEPRECATED_FEATURE_IN_ICXML;
    144157}
    145158
    146159inline void ValidationContextImpl::setElemStack(ElemStack*)
    147160{
    148         DEPRECATED_FEATURE_IN_ICXML;
     161    DEPRECATED_FEATURE_IN_ICXML;
    149162}
    150163
    151 inline void ValidationContextImpl::setScanner(XMLScanner* scanner)
     164inline void ValidationContextImpl::setNamespaceScope(NamespaceScope*)
    152165{
    153         fScanner = scanner;
    154 }
    155 
    156 inline void ValidationContextImpl::setNamespaceScope(NamespaceScope* nsStack)
    157 {
    158         fNamespaceScope = nsStack;
     166    DEPRECATED_FEATURE_IN_ICXML;
    159167}
    160168
  • icXML/icXML-devel/src/icxercesc/internal/VecAttributesImpl.cpp

    r3103 r3564  
    2626#include <xercesc/util/Janitor.hpp>
    2727#include <xercesc/internal/VecAttributesImpl.hpp>
     28#include <icxmlc/XMLNamespaceResolver.hpp>
    2829
    2930XERCES_CPP_NAMESPACE_BEGIN
     
    105106
    106107        const unsigned int uriId =
    107                 const_cast<XMLScanner*>(fScanner)->getUriResolver()->resolveUriId(uri);
     108        const_cast<XMLScanner*>(fScanner)->getNamespaceResolver()->resolveUriId(uri);
    108109        for (XMLSize_t i = 0; i < fCount; i++)
    109110        {
     
    126127        //
    127128        const unsigned int uriId =
    128                 const_cast<XMLScanner*>(fScanner)->getUriResolver()->resolveUriId(uri);
     129        const_cast<XMLScanner*>(fScanner)->getNamespaceResolver()->resolveUriId(uri);
    129130        for (XMLSize_t i = 0; i < fCount; i++)
    130131        {
  • icXML/icXML-devel/src/icxercesc/internal/WFXMLScanner.cpp

    r3157 r3564  
    299299void WFXMLScanner::commonInit()
    300300{
    301 
     301    fEntityTable = new (fMemoryManager) ValueHashTableOf<XMLCh>(5, fMemoryManager);
     302    //  Add the default entity entries for the character refs that must always be present.
     303    fEntityTable->put((void*) XMLUni::fgAmp, chAmpersand);
     304    fEntityTable->put((void*) XMLUni::fgLT, chOpenAngle);
     305    fEntityTable->put((void*) XMLUni::fgGT, chCloseAngle);
     306    fEntityTable->put((void*) XMLUni::fgQuot, chDoubleQuote);
     307    fEntityTable->put((void*) XMLUni::fgApos, chSingleQuote);
     308}
     309
     310void WFXMLScanner::setLocator(Locator *)
     311{
     312    /* do nothing */
    302313}
    303314
    304315void WFXMLScanner::cleanUp()
    305316{
    306 
     317    delete fEntityTable;
    307318}
    308319
  • icXML/icXML-devel/src/icxercesc/internal/WFXMLScanner.hpp

    r3157 r3564  
    8989        );
    9090
    91     bool toCheckIdentityConstraint() const;
    92 
    9391    // -----------------------------------------------------------------------
    9492    //  XMLParser Callback Methods
     
    9997        const XMLCh       *             content
    10098        , const XMLSize_t               length
     99        , const XMLContentFlag          flags
    101100        , const bool                    doPSVI
    102         , const XMLContentFlag          flags
    103101        , XMLDocumentAccumulator &      parser
    104102        , const bool                    forceWrite = false
     
    110108        const XMLCh       *             cdata
    111109        , const XMLSize_t               length
     110        , const bool                    doPSVI
    112111        , XMLDocumentAccumulator &      parser
    113112    );
     
    118117        XMLSymbol &                     element
    119118        , const unsigned int            uriId
    120         , const bool                    isRoot
     119        , const bool                    isRoot       
    121120        , const bool                    doPSVI
     121        , const bool                    hasIdentityConstraint
     122        , const bool                    error
    122123        , XMLDocumentAccumulator &      parser
    123124    );
     
    135136        , const Grammar::GrammarType    grammarType
    136137        , const bool                    doPSVI
     138        , bool &                        error
    137139        , XMLDocumentAccumulator &      parser
    138         , const bool                    write
     140        , const bool                    write = false
    139141    );
    140142
     
    151153        , const Grammar::GrammarType    grammarType
    152154        , const bool                    doPSVI
     155        , bool &                        error
    153156        , XMLDocumentAccumulator &      parser
    154157    );
     
    157160    void validateEndTag
    158161        (
    159         XMLElementDecl &                element
    160         , const QName *                 elemName
    161                 , const unsigned int                    uriId
    162                 , const bool                                    isRoot
    163                 , XMLElementDecl **                             children
    164         , const XMLSize_t                               childCount
    165         , const bool                    doPSVI
    166         , XMLDocumentAccumulator &      parser
     162        XMLElementDecl &                        element
     163        , const QName *                         elemName
     164        , const unsigned int                    uriId
     165        , const bool                            isRoot
     166        , XMLElementDecl **                     children
     167        , const XMLSize_t                       childCount
     168        , const bool                            doPSVI
     169        , bool &                                error
     170        , XMLDocumentAccumulator &              parser
    167171        );
    168172
     
    173177                , const XMLSize_t schemaLocationStrLen
    174178                , bool ignoreLoadSchema = false
     179    );
     180
     181    IDISA_ALWAYS_INLINE
     182    bool expandEntityReference
     183    (
     184        const XMLCh *                   entityReference
     185        , const XMLSize_t               /* length */
     186        , const bool                    inAttributeValue
     187        , XMLBuffer &                   toFill
     188        , bool      &                   isPredefined
     189        , bool      &                   isExternal
     190        , XMLFileLoc &                  line
     191        , XMLFileLoc &                  column
    175192    );
    176193
     
    210227        // -----------------------------------------------------------------------
    211228        void commonInit();
     229    void setLocator(Locator * locator);
    212230        void cleanUp();
    213231
     
    274292        // -----------------------------------------------------------------------
    275293
     294    ValueHashTableOf<XMLCh>*         fEntityTable;
    276295    RefVectorOf<XMLElementDecl>      fElements;
    277296};
     
    290309    const XMLCh       *             content
    291310    , const XMLSize_t               length
     311    , const XMLContentFlag          flags
    292312    , const bool                    doPSVI
    293     , const XMLContentFlag          flags
    294313    , XMLDocumentAccumulator &      parser
    295314    , const bool                    write
    296315)
    297316{
    298     if (length)
    299     {
    300         parser.writeContent(content, length, write);
    301     }
     317    parser.writeContent(content, length, write);
    302318}
    303319
     
    308324    const XMLCh       *             cdata
    309325    , const XMLSize_t               length
     326    , const bool                    /* doPSVI */
    310327    , XMLDocumentAccumulator &      parser
    311328)
    312329{
    313 
     330    parser.writeCDATA(cdata, length);
    314331}
    315332
     
    318335DTDElementDecl & WFXMLScanner::getElementDecl
    319336(
    320     XMLSymbol &                             element
    321     , const unsigned int                    /* uriId */
    322     , const bool                            /* isRoot */
    323     , const bool                            doPSVI
    324     , XMLDocumentAccumulator &              parser   
     337    XMLSymbol &                     element
     338    , const unsigned int            /* uriId */
     339    , const bool                    /* isRoot */   
     340    , const bool                    /* doPSVI */
     341    , const bool                    /* hasIdentityConstraint */
     342    , const bool                    /* error */   
     343    , XMLDocumentAccumulator &      /* parser */
    325344)
    326345{
    327346    //  Lets try to look up the element
    328347    DTDElementDecl * elemDecl = (DTDElementDecl *)element.getElemDecl();
    329 
    330348    if (unlikely(elemDecl == 0))
    331349    {
     
    340358bool WFXMLScanner::validateAttribute
    341359(
    342     const XMLElementDecl &          elemDecl
    343     , const XMLSize_t               elementCount
     360    const XMLElementDecl &          /* elemDecl */
     361    , const XMLSize_t               /* elementCount */
    344362    , const XMLSymbol &             attribute
    345363    , const unsigned int            uriId
     
    347365    , const XMLSize_t               length
    348366    , const MarkupType              type
    349     , const Grammar::GrammarType    grammarType
    350     , const bool                    doPSVI
     367    , const Grammar::GrammarType    /* grammarType */
     368    , const bool                    /* doPSVI */
     369    , bool &                        /* error */
    351370    , XMLDocumentAccumulator &      parser
    352371    , const bool                    write
     
    368387    , const bool                                        isEmpty
    369388    , const Grammar::GrammarType    /* grammarType */
    370     , const bool                    doPSVI
     389    , const bool                    /* doPSVI */
     390    , bool &                        /* error */
    371391    , XMLDocumentAccumulator &      parser
    372392)
     
    381401void WFXMLScanner::validateEndTag
    382402(
    383     XMLElementDecl &                element
    384     , const QName *                 elemName
    385     , const unsigned int                        uriId
    386     , const bool                                        isRoot
    387     , XMLElementDecl **                         children
    388     , const XMLSize_t                           childCount
    389     , const bool                    doPSVI
    390     , XMLDocumentAccumulator &      parser
     403    XMLElementDecl &                        element
     404    , const QName *                         elemName
     405    , const unsigned int                    uriId
     406    , const bool                            isRoot
     407    , XMLElementDecl **                     children
     408    , const XMLSize_t                       childCount
     409    , const bool                            doPSVI
     410    , bool &                                error
     411    , XMLDocumentAccumulator &              parser
    391412)
    392413{
     
    401422}
    402423
    403 inline bool WFXMLScanner::toCheckIdentityConstraint() const
    404 {
    405     return 0;
    406 }
    407 
     424bool WFXMLScanner::expandEntityReference
     425(
     426    const XMLCh *                   entityReference
     427    , const XMLSize_t               /* length */
     428    , const bool                    inAttributeValue
     429    , XMLBuffer &                   toFill
     430    , bool      &                   isPredefined
     431    , bool      &                   isExternal
     432    , XMLFileLoc &                  line
     433    , XMLFileLoc &                  column
     434)
     435{
     436    const XMLCh predefinedEntity = fEntityTable->get(entityReference);
     437    if (predefinedEntity)
     438    {
     439        toFill.set(predefinedEntity);
     440        isPredefined = true;
     441        return true;
     442    }
     443    return false;
     444}
    408445
    409446XERCES_CPP_NAMESPACE_END
  • icXML/icXML-devel/src/icxercesc/internal/XMLReader.cpp

    r3157 r3564  
    3939#include <icxmlc/XMLNameChars.hpp>
    4040#include <icxmlc/XMLWhitespaceNormalizer.hpp>
     41#include <icxmlc/XMLParser.hpp>
    4142
    4243XERCES_CPP_NAMESPACE_BEGIN
     
    9394        , fMemoryManager(manager)
    9495{
    95     DEBUG_MESSAGE("XMLReader(...) 1")
    96 
    9796        // Do an initial load of raw bytes
    9897        refreshRawBuffer(0);
     
    167166        , fMemoryManager(manager)
    168167{
    169     DEBUG_MESSAGE("XMLReader(...) 2")
    170 
    171168        setXMLVersion(version);
    172169
     
    319316        , fMemoryManager(manager)
    320317{
    321     DEBUG_MESSAGE("XMLReader(...) 3")
    322 
    323318        setXMLVersion(version);
    324319
     
    533528        delete fTranscoder;
    534529
    535     DEBUG_MESSAGE("fEncodingStr=" << fEncodingStr << " fEncoding=" << fEncoding)
    536 
    537530        //
    538531        //  Create a transcoder for the encoding. Since the encoding has been
     
    574567{
    575568        delete fCharacterSetAdapter;
    576 
    577     DEBUG_MESSAGE("constructCharacterSetAdapter(" << fTranscoder->getEncodingName() << ")")
    578569
    579570        switch (fEncoding)
     
    869860void XMLReader::refreshRawBuffer(const XMLSize_t from, const XMLSize_t to)
    870861{
    871     DEBUG_MESSAGE("XMLReader::refreshRawBuffer(from=" << from << ",to=" << to << ')')
    872 
    873862    #ifdef PRINT_DEBUG_MESSAGE
    874863    // clear out the "used" data from the buffer if and only if we're going to print it out
     
    888877void XMLReader::refreshRawBuffer(const XMLSize_t offset)
    889878{
    890     DEBUG_MESSAGE("XMLReader::refreshRawBuffer(offset=" << offset << ')')
    891 
    892879    fRawBytesRead = fStream->readBytes(&fRawByteBuf[offset], (kRawBufSize + sizeof(BytePack)) - offset) + offset;
    893880    if (likely(fRawBytesRead > kRawBufSize))
     
    914901void XMLReader::refreshRawBuffer()
    915902{
    916     DEBUG_MESSAGE("XMLReader::refreshRawBuffer()")
    917 
    918903    //
    919904    //  If there are any bytes left, move them down to the start. There
     
    938923bool XMLReader::refreshCharBuffer()
    939924{
    940     DEBUG_MESSAGE("XMLReader::refreshCharBuffer()")
    941 
    942925    // If the no more flag is set, then don't bother doing anything.
    943926    if (unlikely(fNoMore))
     
    983966    if (u