Changeset 2747 for icXML/icXML-devel


Ignore:
Timestamp:
Dec 4, 2012, 6:02:04 PM (6 years ago)
Author:
cameron
Message:

Script for generating link files.

Location:
icXML/icXML-devel
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/xercesc/validators/schema/ComplexTypeInfo.hpp

    r2722 r2747  
    1 /*
    2  * Licensed to the Apache Software Foundation (ASF) under one or more
    3  * contributor license agreements.  See the NOTICE file distributed with
    4  * this work for additional information regarding copyright ownership.
    5  * The ASF licenses this file to You under the Apache License, Version 2.0
    6  * (the "License"); you may not use this file except in compliance with
    7  * the License.  You may obtain a copy of the License at
    8  *
    9  *      http://www.apache.org/licenses/LICENSE-2.0
    10  *
    11  * Unless required by applicable law or agreed to in writing, software
    12  * distributed under the License is distributed on an "AS IS" BASIS,
    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  * See the License for the specific language governing permissions and
    15  * limitations under the License.
    16  */
    17 
    18 /*
    19  * $Id: ComplexTypeInfo.hpp 932887 2010-04-11 13:04:59Z borisk $
    20  */
    21 
    22 #if !defined(XERCESC_INCLUDE_GUARD_COMPLEXTYPEINFO_HPP)
    23 #define XERCESC_INCLUDE_GUARD_COMPLEXTYPEINFO_HPP
    24 
    25 
    26 /**
    27   * The class act as a place holder to store complex type information.
    28   *
    29   * The class is intended for internal use.
    30   */
    31 
    32 // ---------------------------------------------------------------------------
    33 //  Includes
    34 // ---------------------------------------------------------------------------
    35 #include <icxercesc/util/XMLString.hpp>
    36 #include <xercesc/util/RefHash2KeysTableOf.hpp>
    37 #include <xercesc/util/RefVectorOf.hpp>
    38 #include <icxercesc/framework/XMLElementDecl.hpp>
    39 #include <icxercesc/framework/XMLContentModel.hpp>
    40 #include <xercesc/validators/schema/SchemaAttDef.hpp>
    41 #include <xercesc/internal/XSerializable.hpp>
    42 
    43 XERCES_CPP_NAMESPACE_BEGIN
    44 
    45 
    46 // ---------------------------------------------------------------------------
    47 //  Forward Declarations
    48 // ---------------------------------------------------------------------------
    49 class DatatypeValidator;
    50 class ContentSpecNode;
    51 class SchemaAttDefList;
    52 class SchemaElementDecl;
    53 class XSDLocator;
    54 
    55 
    56 class VALIDATORS_EXPORT ComplexTypeInfo : public XSerializable, public XMemory
    57 {
    58 public:
    59     // -----------------------------------------------------------------------
    60     //  Public Constructors/Destructor
    61     // -----------------------------------------------------------------------
    62     ComplexTypeInfo(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
    63     ~ComplexTypeInfo();
    64 
    65     // -----------------------------------------------------------------------
    66     //  Getter methods
    67     // -----------------------------------------------------------------------
    68     bool                     getAbstract() const;
    69     bool                     getAdoptContentSpec() const;
    70     bool                     containsAttWithTypeId() const;
    71     bool                     getPreprocessed() const;
    72     int                      getDerivedBy() const;
    73     int                      getBlockSet() const;
    74     int                      getFinalSet() const;
    75     unsigned int             getScopeDefined() const;
    76     unsigned int             getElementId() const;
    77     int                      getContentType() const;
    78     XMLSize_t                elementCount() const;
    79     XMLCh*                   getTypeName() const;
    80     DatatypeValidator*       getBaseDatatypeValidator() const;
    81     DatatypeValidator*       getDatatypeValidator() const;
    82     ComplexTypeInfo*         getBaseComplexTypeInfo() const;
    83     ContentSpecNode*         getContentSpec() const;
    84     const SchemaAttDef*      getAttWildCard() const;
    85     SchemaAttDef*            getAttWildCard();
    86     const SchemaAttDef*      getAttDef(const XMLCh* const baseName,
    87                                        const int uriId) const;
    88     SchemaAttDef*            getAttDef(const XMLCh* const baseName,
    89                                        const int uriId);
    90     XMLAttDefList&           getAttDefList() const;
    91     const SchemaElementDecl* elementAt(const XMLSize_t index) const;
    92     SchemaElementDecl*       elementAt(const XMLSize_t index);
    93     XMLContentModel*         getContentModel(const bool checkUPA = false);
    94     const XMLCh*             getFormattedContentModel ()   const;
    95     XSDLocator*              getLocator() const;
    96     const XMLCh*             getTypeLocalName() const;
    97     const XMLCh*             getTypeUri() const;
    98 
    99     /**
    100      * returns true if this type is anonymous
    101      **/
    102     bool getAnonymous() const;
    103 
    104     // -----------------------------------------------------------------------
    105     //  Setter methods
    106     // -----------------------------------------------------------------------
    107     void setAbstract(const bool isAbstract);
    108     void setAdoptContentSpec(const bool toAdopt);
    109     void setAttWithTypeId(const bool value);
    110     void setPreprocessed(const bool aValue = true);
    111     void setDerivedBy(const int derivedBy);
    112     void setBlockSet(const int blockSet);
    113     void setFinalSet(const int finalSet);
    114     void setScopeDefined(const unsigned int scopeDefined);
    115     void setElementId(const unsigned int elemId);
    116     void setTypeName(const XMLCh* const typeName);
    117     void setContentType(const int contentType);
    118     void setBaseDatatypeValidator(DatatypeValidator* const baseValidator);
    119     void setDatatypeValidator(DatatypeValidator* const validator);
    120     void setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo);
    121     void setContentSpec(ContentSpecNode* const toAdopt);
    122     void setAttWildCard(SchemaAttDef* const toAdopt);
    123     void addAttDef(SchemaAttDef* const toAdd);
    124     void addElement(SchemaElementDecl* const toAdd);
    125     void setLocator(XSDLocator* const aLocator);
    126 
    127     /**
    128      * sets this type to be anonymous
    129      **/
    130     void setAnonymous();
    131 
    132     // -----------------------------------------------------------------------
    133     //  Helper methods
    134     // -----------------------------------------------------------------------
    135     bool hasAttDefs() const;
    136     bool contains(const XMLCh* const attName);
    137     void checkUniqueParticleAttribution
    138     (
    139         SchemaGrammar*    const pGrammar
    140       , GrammarResolver*  const pGrammarResolver
    141       , XMLStringPool*    const pStringPool
    142       , XMLValidator*     const pValidator
    143     ) ;
    144 
    145     /**
    146       * Return a singleton that represents 'anyType'
    147       *
    148       * @param emptyNSId the uri id of the empty namespace
    149       */
    150     static ComplexTypeInfo* getAnyType(unsigned int emptyNSId);
    151 
    152     /**
    153       *  Notification that lazy data has been deleted
    154       */
    155     static void reinitAnyType();
    156 
    157     /***
    158      * Support for Serialization/De-serialization
    159      ***/
    160     DECL_XSERIALIZABLE(ComplexTypeInfo)
    161 
    162 private:
    163     // -----------------------------------------------------------------------
    164     //  Unimplemented constructors and operators
    165     // -----------------------------------------------------------------------
    166     ComplexTypeInfo(const ComplexTypeInfo& elemInfo);
    167     ComplexTypeInfo& operator= (const ComplexTypeInfo& other);
    168 
    169     // -----------------------------------------------------------------------
    170     //  Private helper methods
    171     // -----------------------------------------------------------------------
    172     void faultInAttDefList() const;
    173     bool useRepeatingLeafNodes(ContentSpecNode* particle);
    174     XMLContentModel* makeContentModel(bool checkUPA = false);
    175     XMLCh* formatContentModel () const ;
    176     ContentSpecNode* expandContentModel(ContentSpecNode* const curNode, int minOccurs, int maxOccurs, bool bAllowCompactSyntax);
    177     ContentSpecNode* convertContentSpecTree(ContentSpecNode* const curNode, bool checkUPA, bool bAllowCompactSyntax);
    178     void resizeContentSpecOrgURI();
    179 
    180     // -----------------------------------------------------------------------
    181     //  Private data members
    182     // -----------------------------------------------------------------------
    183     bool                               fAnonymous;
    184     bool                               fAbstract;
    185     bool                               fAdoptContentSpec;
    186     bool                               fAttWithTypeId;
    187     bool                               fPreprocessed;
    188     int                                fDerivedBy;
    189     int                                fBlockSet;
    190     int                                fFinalSet;
    191     unsigned int                       fScopeDefined;
    192     int                                fContentType;
    193 
    194     unsigned int                       fElementId;
    195     unsigned int                       fUniqueURI;
    196     unsigned int                       fContentSpecOrgURISize;
    197 
    198     XMLCh*                             fTypeName;
    199     XMLCh*                             fTypeLocalName;
    200     XMLCh*                             fTypeUri;
    201     DatatypeValidator*                 fBaseDatatypeValidator;
    202     DatatypeValidator*                 fDatatypeValidator;
    203     ComplexTypeInfo*                   fBaseComplexTypeInfo;
    204     ContentSpecNode*                   fContentSpec;
    205     SchemaAttDef*                      fAttWildCard;
    206     SchemaAttDefList*                  fAttList;
    207     RefVectorOf<SchemaElementDecl>*    fElements;
    208     RefHash2KeysTableOf<SchemaAttDef>* fAttDefs;
    209     XMLContentModel*                   fContentModel;
    210     XMLCh*                             fFormattedModel;
    211     unsigned int*                      fContentSpecOrgURI;
    212     XSDLocator*                        fLocator;
    213     MemoryManager*                     fMemoryManager;
    214 
    215     static ComplexTypeInfo*            fAnyType;
    216 
    217     friend class XMLInitializer;
    218 };
    219 
    220 // ---------------------------------------------------------------------------
    221 //  ComplexTypeInfo: Getter methods
    222 // ---------------------------------------------------------------------------
    223 inline bool ComplexTypeInfo::getAbstract() const {
    224 
    225     return fAbstract;
    226 }
    227 
    228 inline bool ComplexTypeInfo::getAdoptContentSpec() const {
    229 
    230     return fAdoptContentSpec;
    231 }
    232 
    233 inline bool ComplexTypeInfo::containsAttWithTypeId() const {
    234 
    235     return fAttWithTypeId;
    236 }
    237 
    238 inline bool ComplexTypeInfo::getPreprocessed() const {
    239 
    240     return fPreprocessed;
    241 }
    242 
    243 inline int ComplexTypeInfo::getDerivedBy() const {
    244 
    245     return fDerivedBy;
    246 }
    247 
    248 inline int ComplexTypeInfo::getBlockSet() const {
    249 
    250     return fBlockSet;
    251 }
    252 
    253 inline int ComplexTypeInfo::getFinalSet() const {
    254 
    255     return fFinalSet;
    256 }
    257 
    258 inline unsigned int ComplexTypeInfo::getScopeDefined() const {
    259 
    260     return fScopeDefined;
    261 }
    262 
    263 inline unsigned int ComplexTypeInfo::getElementId() const {
    264 
    265     return fElementId;
    266 }
    267 
    268 inline int ComplexTypeInfo::getContentType() const {
    269 
    270     return fContentType;
    271 }
    272 
    273 inline XMLSize_t ComplexTypeInfo::elementCount() const {
    274 
    275     if (fElements) {
    276         return fElements->size();
    277     }
    278 
    279     return 0;
    280 }
    281 
    282 inline XMLCh* ComplexTypeInfo::getTypeName() const {
    283     return fTypeName;
    284 }
    285 
    286 inline DatatypeValidator* ComplexTypeInfo::getBaseDatatypeValidator() const {
    287 
    288     return fBaseDatatypeValidator;
    289 }
    290 
    291 inline DatatypeValidator* ComplexTypeInfo::getDatatypeValidator() const {
    292 
    293     return fDatatypeValidator;
    294 }
    295 
    296 inline ComplexTypeInfo* ComplexTypeInfo::getBaseComplexTypeInfo() const {
    297 
    298     return fBaseComplexTypeInfo;
    299 }
    300 
    301 inline ContentSpecNode* ComplexTypeInfo::getContentSpec() const {
    302 
    303     return fContentSpec;
    304 }
    305 
    306 inline const SchemaAttDef* ComplexTypeInfo::getAttWildCard() const {
    307 
    308     return fAttWildCard;
    309 }
    310 
    311 inline SchemaAttDef* ComplexTypeInfo::getAttWildCard() {
    312 
    313     return fAttWildCard;
    314 }
    315 
    316 inline const SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName,
    317                                                       const int uriId) const {
    318 
    319     return fAttDefs->get(baseName, uriId);
    320 }
    321 
    322 inline SchemaAttDef* ComplexTypeInfo::getAttDef(const XMLCh* const baseName,
    323                                                 const int uriId)
    324 {
    325     return fAttDefs->get(baseName, uriId);
    326 }
    327 
    328 inline SchemaElementDecl*
    329 ComplexTypeInfo::elementAt(const XMLSize_t index) {
    330 
    331     if (!fElements) {
    332         return 0; // REVISIT - need to throw an exception
    333     }
    334 
    335     return fElements->elementAt(index);
    336 }
    337 
    338 inline const SchemaElementDecl*
    339 ComplexTypeInfo::elementAt(const XMLSize_t index) const {
    340 
    341     if (!fElements) {
    342         return 0; // REVISIT - need to throw an exception
    343     }
    344 
    345     return fElements->elementAt(index);
    346 }
    347 
    348 inline XMLContentModel* ComplexTypeInfo::getContentModel(const bool checkUPA)
    349 {
    350     if (!fContentModel && fContentSpec)
    351         fContentModel = makeContentModel(checkUPA);
    352 
    353     return fContentModel;
    354 }
    355 
    356 inline XSDLocator* ComplexTypeInfo::getLocator() const
    357 {
    358     return fLocator;
    359 }
    360 
    361 inline bool ComplexTypeInfo::getAnonymous() const {
    362     return fAnonymous;
    363 }
    364 
    365 inline const XMLCh* ComplexTypeInfo::getTypeLocalName() const
    366 {
    367     return fTypeLocalName;
    368 }
    369 
    370 inline const XMLCh* ComplexTypeInfo::getTypeUri() const
    371 {
    372    return fTypeUri;
    373 }
    374 
    375 // ---------------------------------------------------------------------------
    376 //  ComplexTypeInfo: Setter methods
    377 // ---------------------------------------------------------------------------
    378 inline void ComplexTypeInfo::setAbstract(const bool isAbstract) {
    379 
    380     fAbstract = isAbstract;
    381 }
    382 
    383 inline void ComplexTypeInfo::setAdoptContentSpec(const bool toAdopt) {
    384 
    385     fAdoptContentSpec = toAdopt;
    386 }
    387 
    388 inline void ComplexTypeInfo::setAttWithTypeId(const bool value) {
    389 
    390     fAttWithTypeId = value;
    391 }
    392 
    393 inline void ComplexTypeInfo::setPreprocessed(const bool aValue) {
    394 
    395     fPreprocessed = aValue;
    396 }
    397 
    398 inline void ComplexTypeInfo::setDerivedBy(const int derivedBy) {
    399 
    400     fDerivedBy = derivedBy;
    401 }
    402 
    403 inline void ComplexTypeInfo::setBlockSet(const int blockSet) {
    404 
    405     fBlockSet = blockSet;
    406 }
    407 
    408 inline void ComplexTypeInfo::setFinalSet(const int finalSet) {
    409 
    410     fFinalSet = finalSet;
    411 }
    412 
    413 inline void ComplexTypeInfo::setScopeDefined(const unsigned int scopeDefined) {
    414 
    415     fScopeDefined = scopeDefined;
    416 }
    417 
    418 inline void ComplexTypeInfo::setElementId(const unsigned int elemId) {
    419 
    420     fElementId = elemId;
    421 }
    422 
    423 inline void
    424 ComplexTypeInfo::setContentType(const int contentType) {
    425 
    426     fContentType = contentType;
    427 }
    428 
    429 inline void ComplexTypeInfo::setTypeName(const XMLCh* const typeName) {
    430 
    431     fMemoryManager->deallocate(fTypeName);//delete [] fTypeName;
    432     fMemoryManager->deallocate(fTypeLocalName);//delete [] fTypeLocalName;
    433     fMemoryManager->deallocate(fTypeUri);//delete [] fTypeUri;
    434 
    435     if (typeName)
    436     {
    437         fTypeName = XMLString::replicate(typeName, fMemoryManager);
    438 
    439         int index = XMLString::indexOf(fTypeName, chComma);
    440         XMLSize_t length = XMLString::stringLen(fTypeName);
    441         fTypeLocalName = (XMLCh*) fMemoryManager->allocate
    442         (
    443             (length - index + 1) * sizeof(XMLCh)
    444         ); //new XMLCh[length - index + 1];
    445         XMLString::subString(fTypeLocalName, fTypeName, index + 1, length, fMemoryManager);
    446 
    447         fTypeUri = (XMLCh*) fMemoryManager->allocate
    448         (
    449             (index + 1) * sizeof(XMLCh)
    450         ); //new XMLCh[index + 1];
    451         XMLString::subString(fTypeUri, fTypeName, 0, index, fMemoryManager);
    452     }
    453     else
    454     {
    455         fTypeName = fTypeLocalName = fTypeUri = 0;
    456     }
    457 }
    458 
    459 inline void
    460 ComplexTypeInfo::setBaseDatatypeValidator(DatatypeValidator* const validator) {
    461 
    462     fBaseDatatypeValidator = validator;
    463 }
    464 
    465 inline void
    466 ComplexTypeInfo::setDatatypeValidator(DatatypeValidator* const validator) {
    467 
    468     fDatatypeValidator = validator;
    469 }
    470 
    471 inline void
    472 ComplexTypeInfo::setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo) {
    473 
    474     fBaseComplexTypeInfo = typeInfo;
    475 }
    476 
    477 inline void ComplexTypeInfo::addElement(SchemaElementDecl* const elem) {
    478 
    479     if (!fElements) {
    480         fElements = new (fMemoryManager) RefVectorOf<SchemaElementDecl>(8, false, fMemoryManager);
    481     }
    482     else if (fElements->containsElement(elem)) {
    483         return;
    484     }
    485 
    486     fElements->addElement(elem);
    487 }
    488 
    489 inline void ComplexTypeInfo::setAttWildCard(SchemaAttDef* const toAdopt) {
    490 
    491     if (fAttWildCard) {
    492        delete fAttWildCard;
    493     }
    494 
    495     fAttWildCard = toAdopt;
    496 }
    497 
    498 inline void ComplexTypeInfo::setAnonymous() {
    499     fAnonymous = true;
    500 }
    501 
    502 // ---------------------------------------------------------------------------
    503 //  ComplexTypeInfo: Helper methods
    504 // ---------------------------------------------------------------------------
    505 inline bool ComplexTypeInfo::hasAttDefs() const
    506 {
    507     return !fAttDefs->isEmpty();
    508 }
    509 
    510 inline bool ComplexTypeInfo::contains(const XMLCh* const attName) {
    511 
    512     RefHash2KeysTableOfEnumerator<SchemaAttDef> enumDefs(fAttDefs, false, fMemoryManager);
    513 
    514     while (enumDefs.hasMoreElements()) {
    515 
    516         if (XMLString::equals(attName, enumDefs.nextElement().getAttName()->getLocalPart())) {
    517             return true;
    518         }
    519     }
    520 
    521     return false;
    522 }
    523 
    524 XERCES_CPP_NAMESPACE_END
    525 
    526 #endif
    527 
    528 /**
    529   * End of file ComplexTypeInfo.hpp
    530   */
    531 
     1#include <icxercesc/validators/schema/ComplexTypeInfo.hpp>
  • icXML/icXML-devel/src/xercesc/validators/schema/SchemaSymbols.cpp

    r2732 r2747  
    1 /*
    2  * Licensed to the Apache Software Foundation (ASF) under one or more
    3  * contributor license agreements.  See the NOTICE file distributed with
    4  * this work for additional information regarding copyright ownership.
    5  * The ASF licenses this file to You under the Apache License, Version 2.0
    6  * (the "License"); you may not use this file except in compliance with
    7  * the License.  You may obtain a copy of the License at
    8  *
    9  *      http://www.apache.org/licenses/LICENSE-2.0
    10  *
    11  * Unless required by applicable law or agreed to in writing, software
    12  * distributed under the License is distributed on an "AS IS" BASIS,
    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  * See the License for the specific language governing permissions and
    15  * limitations under the License.
    16  */
    17 
    18 /*
    19  * $Id: SchemaSymbols.cpp 802804 2009-08-10 14:21:48Z amassari $
    20  */
    21 
    22 
    23 // ---------------------------------------------------------------------------
    24 //  Includes
    25 // ---------------------------------------------------------------------------
    26 #include <xercesc/util/XMLUniDefs.hpp>
    27 #include <icxercesc/validators/schema/SchemaSymbols.hpp>
    28 
    29 XERCES_CPP_NAMESPACE_BEGIN
    30 
    31 // ---------------------------------------------------------------------------
    32 //  SchemaSymbols: Static data
    33 // ---------------------------------------------------------------------------
    34 const XMLCh SchemaSymbols::fgURI_XSI[] =
    35 {
    36     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash,
    37     chForwardSlash, chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w,
    38     chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
    39     chDigit_2, chDigit_0, chDigit_0, chDigit_1, chForwardSlash,
    40     chLatin_X, chLatin_M, chLatin_L, chLatin_S,
    41     chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a, chDash, chLatin_i,
    42     chLatin_n, chLatin_s, chLatin_t, chLatin_a, chLatin_n, chLatin_c,
    43     chLatin_e, chNull
    44 };
    45 
    46 const XMLCh SchemaSymbols::fgURI_SCHEMAFORSCHEMA[] =
    47 {
    48     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash,
    49     chForwardSlash, chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w,
    50     chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
    51     chDigit_2, chDigit_0, chDigit_0, chDigit_1, chForwardSlash,
    52     chLatin_X, chLatin_M, chLatin_L, chLatin_S,
    53     chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a, chNull
    54 };
    55 
    56 // deprecated (typo)
    57 const XMLCh SchemaSymbols::fgXSI_SCHEMALOCACTION[] =
    58 {
    59     chLatin_s, chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a,
    60     chLatin_L, chLatin_o, chLatin_c, chLatin_a, chLatin_t, chLatin_i,
    61     chLatin_o, chLatin_n, chNull
    62 };
    63 
    64 // deprecated (typo)
    65 const XMLCh SchemaSymbols::fgXSI_NONAMESPACESCHEMALOCACTION[] =
    66 {
    67     chLatin_n, chLatin_o, chLatin_N, chLatin_a, chLatin_m, chLatin_e,
    68     chLatin_s, chLatin_p, chLatin_a, chLatin_c, chLatin_e, chLatin_S,
    69     chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a, chLatin_L,
    70     chLatin_o, chLatin_c, chLatin_a, chLatin_t, chLatin_i, chLatin_o,
    71     chLatin_n, chNull
    72 };
    73 
    74 const XMLCh SchemaSymbols::fgXSI_SCHEMALOCATION[] =
    75 {
    76     chLatin_s, chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a,
    77     chLatin_L, chLatin_o, chLatin_c, chLatin_a, chLatin_t, chLatin_i,
    78     chLatin_o, chLatin_n, chNull
    79 };
    80 
    81 const XMLCh SchemaSymbols::fgXSI_NONAMESPACESCHEMALOCATION[] =
    82 {
    83     chLatin_n, chLatin_o, chLatin_N, chLatin_a, chLatin_m, chLatin_e,
    84     chLatin_s, chLatin_p, chLatin_a, chLatin_c, chLatin_e, chLatin_S,
    85     chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a, chLatin_L,
    86     chLatin_o, chLatin_c, chLatin_a, chLatin_t, chLatin_i, chLatin_o,
    87     chLatin_n, chNull
    88 };
    89 
    90 const XMLCh SchemaSymbols::fgXSI_TYPE[] =
    91 {
    92     chLatin_t, chLatin_y, chLatin_p, chLatin_e, chNull
    93 };
    94 
    95 const XMLCh SchemaSymbols::fgELT_ALL[] =
    96 {
    97     chLatin_a, chLatin_l, chLatin_l, chNull
    98 };
    99 
    100 const XMLCh SchemaSymbols::fgELT_ANNOTATION[] =
    101 {
    102     chLatin_a, chLatin_n, chLatin_n, chLatin_o, chLatin_t, chLatin_a,
    103     chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    104 };
    105 
    106 const XMLCh SchemaSymbols::fgELT_ANY[] =
    107 {
    108     chLatin_a, chLatin_n, chLatin_y, chNull
    109 };
    110 
    111 const XMLCh SchemaSymbols::fgELT_WILDCARD[] =
    112 {
    113     chLatin_a, chLatin_n, chLatin_y, chNull
    114 };
    115 
    116 const XMLCh SchemaSymbols::fgELT_ANYATTRIBUTE[] =
    117 {
    118     chLatin_a, chLatin_n, chLatin_y, chLatin_A, chLatin_t, chLatin_t,
    119     chLatin_r, chLatin_i, chLatin_b, chLatin_u, chLatin_t, chLatin_e, chNull
    120 };
    121 
    122 const XMLCh SchemaSymbols::fgELT_APPINFO[] =
    123 {
    124     chLatin_a, chLatin_p, chLatin_p, chLatin_i, chLatin_n, chLatin_f, chLatin_o, chNull
    125 };
    126 
    127 const XMLCh SchemaSymbols::fgELT_ATTRIBUTE[] =
    128 {
    129     chLatin_a, chLatin_t, chLatin_t, chLatin_r, chLatin_i, chLatin_b,
    130     chLatin_u, chLatin_t, chLatin_e, chNull
    131 };
    132 
    133 const XMLCh SchemaSymbols::fgELT_ATTRIBUTEGROUP[] =
    134 {
    135     chLatin_a, chLatin_t, chLatin_t, chLatin_r, chLatin_i, chLatin_b,
    136     chLatin_u, chLatin_t, chLatin_e, chLatin_G, chLatin_r, chLatin_o,
    137     chLatin_u, chLatin_p, chNull
    138 };
    139 
    140 const XMLCh SchemaSymbols::fgELT_CHOICE[] =
    141 {
    142     chLatin_c, chLatin_h, chLatin_o, chLatin_i, chLatin_c, chLatin_e, chNull
    143 };
    144 
    145 const XMLCh SchemaSymbols::fgELT_COMPLEXTYPE[] =
    146 {
    147     chLatin_c, chLatin_o, chLatin_m, chLatin_p, chLatin_l, chLatin_e,
    148     chLatin_x, chLatin_T, chLatin_y, chLatin_p, chLatin_e, chNull
    149 };
    150 
    151 const XMLCh SchemaSymbols::fgELT_CONTENT[] =
    152 {
    153     chLatin_c, chLatin_o, chLatin_n, chLatin_t, chLatin_e, chLatin_n,
    154     chLatin_t, chNull
    155 };
    156 
    157 const XMLCh SchemaSymbols::fgELT_DOCUMENTATION[] =
    158 {
    159     chLatin_d, chLatin_o, chLatin_c, chLatin_u, chLatin_m, chLatin_e, chLatin_n,
    160     chLatin_t, chLatin_a, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    161 };
    162 
    163 const XMLCh SchemaSymbols::fgELT_DURATION[] =
    164 {
    165     chLatin_d, chLatin_u, chLatin_r, chLatin_a, chLatin_t, chLatin_i,
    166     chLatin_o, chLatin_n, chNull
    167 };
    168 
    169 const XMLCh SchemaSymbols::fgELT_ELEMENT[] =
    170 {
    171     chLatin_e, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n,
    172         chLatin_t, chNull
    173 };
    174 
    175 const XMLCh SchemaSymbols::fgELT_ENCODING[] =
    176 {
    177     chLatin_e, chLatin_n, chLatin_c, chLatin_o, chLatin_d, chLatin_i,
    178     chLatin_n, chLatin_g, chNull
    179 };
    180 
    181 const XMLCh SchemaSymbols::fgELT_ENUMERATION[] =
    182 {
    183     chLatin_e, chLatin_n, chLatin_u, chLatin_m, chLatin_e, chLatin_r,
    184     chLatin_a, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    185 };
    186 
    187 const XMLCh SchemaSymbols::fgELT_FIELD[] =
    188 {
    189     chLatin_f, chLatin_i, chLatin_e, chLatin_l, chLatin_d, chNull
    190 };
    191 
    192 
    193 const XMLCh SchemaSymbols::fgELT_WHITESPACE[] =
    194 {
    195     chLatin_w, chLatin_h, chLatin_i, chLatin_t, chLatin_e, chLatin_S,
    196     chLatin_p, chLatin_a, chLatin_c, chLatin_e, chNull
    197 };
    198 
    199 const XMLCh SchemaSymbols::fgELT_GROUP[] =
    200 {
    201     chLatin_g, chLatin_r, chLatin_o, chLatin_u, chLatin_p,  chNull
    202 };
    203 
    204 const XMLCh SchemaSymbols::fgELT_IMPORT[] =
    205 {
    206     chLatin_i, chLatin_m, chLatin_p, chLatin_o, chLatin_r, chLatin_t, chNull
    207 };
    208 
    209 const XMLCh SchemaSymbols::fgELT_INCLUDE[] =
    210 {
    211     chLatin_i, chLatin_n, chLatin_c, chLatin_l, chLatin_u, chLatin_d,
    212     chLatin_e, chNull
    213 };
    214 
    215 const XMLCh SchemaSymbols::fgELT_REDEFINE[] =
    216 {
    217     chLatin_r, chLatin_e, chLatin_d, chLatin_e, chLatin_f, chLatin_i,
    218     chLatin_n, chLatin_e, chNull
    219 };
    220 
    221 const XMLCh SchemaSymbols::fgELT_KEY[] =
    222 {
    223     chLatin_k, chLatin_e, chLatin_y,  chNull
    224 };
    225 
    226 const XMLCh SchemaSymbols::fgELT_KEYREF[] =
    227 {
    228     chLatin_k, chLatin_e, chLatin_y, chLatin_r, chLatin_e, chLatin_f, chNull
    229 };
    230 
    231 const XMLCh SchemaSymbols::fgELT_LENGTH[] =
    232 {
    233     chLatin_l, chLatin_e, chLatin_n, chLatin_g, chLatin_t, chLatin_h, chNull
    234 };
    235 
    236 const XMLCh SchemaSymbols::fgELT_MAXEXCLUSIVE[] =
    237 {
    238     chLatin_m, chLatin_a, chLatin_x, chLatin_E, chLatin_x, chLatin_c,
    239     chLatin_l, chLatin_u, chLatin_s, chLatin_i, chLatin_v, chLatin_e, chNull
    240 };
    241 
    242 const XMLCh SchemaSymbols::fgELT_MAXINCLUSIVE[] =
    243 {
    244     chLatin_m, chLatin_a, chLatin_x, chLatin_I, chLatin_n, chLatin_c,
    245     chLatin_l, chLatin_u, chLatin_s, chLatin_i, chLatin_v, chLatin_e, chNull
    246 };
    247 
    248 const XMLCh SchemaSymbols::fgELT_MAXLENGTH[] =
    249 {
    250     chLatin_m, chLatin_a, chLatin_x, chLatin_L, chLatin_e, chLatin_n,
    251     chLatin_g, chLatin_t, chLatin_h, chNull
    252 };
    253 
    254 const XMLCh SchemaSymbols::fgELT_MINEXCLUSIVE[] =
    255 {
    256     chLatin_m, chLatin_i, chLatin_n, chLatin_E, chLatin_x, chLatin_c,
    257     chLatin_l, chLatin_u, chLatin_s, chLatin_i, chLatin_v, chLatin_e, chNull
    258 };
    259 
    260 const XMLCh SchemaSymbols::fgELT_MININCLUSIVE[] =
    261 {
    262     chLatin_m, chLatin_i, chLatin_n, chLatin_I, chLatin_n, chLatin_c,
    263     chLatin_l, chLatin_u, chLatin_s, chLatin_i, chLatin_v, chLatin_e, chNull
    264 };
    265 
    266 const XMLCh SchemaSymbols::fgELT_MINLENGTH[] =
    267 {
    268     chLatin_m, chLatin_i, chLatin_n, chLatin_L, chLatin_e, chLatin_n,
    269     chLatin_g, chLatin_t, chLatin_h, chNull
    270 };
    271 
    272 const XMLCh SchemaSymbols::fgELT_NOTATION[] =
    273 {
    274     chLatin_n, chLatin_o, chLatin_t, chLatin_a, chLatin_t, chLatin_i,
    275     chLatin_o, chLatin_n,  chNull
    276 };
    277 
    278 const XMLCh SchemaSymbols::fgELT_PATTERN[] =
    279 {
    280     chLatin_p, chLatin_a, chLatin_t, chLatin_t, chLatin_e, chLatin_r,
    281     chLatin_n,  chNull
    282 };
    283 
    284 const XMLCh SchemaSymbols::fgELT_PERIOD[] =
    285 {
    286     chLatin_p, chLatin_e, chLatin_r, chLatin_i, chLatin_o, chLatin_d, chNull
    287 };
    288 
    289 const XMLCh SchemaSymbols::fgELT_TOTALDIGITS[] =
    290 {
    291     chLatin_t, chLatin_o, chLatin_t, chLatin_a, chLatin_l, chLatin_D,
    292     chLatin_i, chLatin_g, chLatin_i, chLatin_t, chLatin_s, chNull
    293 };
    294 
    295 const XMLCh SchemaSymbols::fgELT_FRACTIONDIGITS[] =
    296 {
    297     chLatin_f, chLatin_r, chLatin_a, chLatin_c, chLatin_t, chLatin_i, chLatin_o,
    298     chLatin_n, chLatin_D, chLatin_i, chLatin_g, chLatin_i, chLatin_t, chLatin_s, chNull
    299 };
    300 
    301 const XMLCh SchemaSymbols::fgELT_SCHEMA[] =
    302 {
    303     chLatin_s, chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a, chNull
    304 };
    305 
    306 const XMLCh SchemaSymbols::fgELT_SELECTOR[] =
    307 {
    308     chLatin_s, chLatin_e, chLatin_l, chLatin_e, chLatin_c, chLatin_t,
    309     chLatin_o, chLatin_r, chNull
    310 };
    311 
    312 const XMLCh SchemaSymbols::fgELT_SEQUENCE[] =
    313 {
    314     chLatin_s, chLatin_e, chLatin_q, chLatin_u, chLatin_e, chLatin_n,
    315     chLatin_c, chLatin_e, chNull
    316 };
    317 
    318 const XMLCh SchemaSymbols::fgELT_SIMPLETYPE[] =
    319 {
    320     chLatin_s, chLatin_i, chLatin_m, chLatin_p, chLatin_l, chLatin_e,
    321     chLatin_T, chLatin_y, chLatin_p, chLatin_e, chNull
    322 };
    323 
    324 const XMLCh SchemaSymbols::fgELT_UNION[] =
    325 {
    326     chLatin_u, chLatin_n, chLatin_i, chLatin_o, chLatin_n,  chNull
    327 };
    328 
    329 const XMLCh SchemaSymbols::fgELT_LIST[] =
    330 {
    331     chLatin_l, chLatin_i, chLatin_s, chLatin_t,  chNull
    332 };
    333 
    334 const XMLCh SchemaSymbols::fgELT_UNIQUE[] =
    335 {
    336     chLatin_u, chLatin_n, chLatin_i, chLatin_q, chLatin_u, chLatin_e, chNull
    337 };
    338 
    339 const XMLCh SchemaSymbols::fgELT_COMPLEXCONTENT[] =
    340 {
    341     chLatin_c, chLatin_o, chLatin_m, chLatin_p, chLatin_l, chLatin_e,
    342     chLatin_x, chLatin_C, chLatin_o, chLatin_n, chLatin_t, chLatin_e,
    343     chLatin_n, chLatin_t, chNull
    344 };
    345 
    346 const XMLCh SchemaSymbols::fgELT_SIMPLECONTENT[] =
    347 {
    348     chLatin_s, chLatin_i, chLatin_m, chLatin_p, chLatin_l, chLatin_e, chLatin_C,
    349     chLatin_o, chLatin_n, chLatin_t, chLatin_e, chLatin_n, chLatin_t, chNull
    350 };
    351 
    352 const XMLCh SchemaSymbols::fgELT_RESTRICTION[] =
    353 {
    354     chLatin_r, chLatin_e, chLatin_s, chLatin_t, chLatin_r, chLatin_i,
    355     chLatin_c, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    356 };
    357 
    358 const XMLCh SchemaSymbols::fgELT_EXTENSION[] =
    359 {
    360     chLatin_e, chLatin_x, chLatin_t, chLatin_e, chLatin_n, chLatin_s,
    361     chLatin_i, chLatin_o, chLatin_n, chNull
    362 };
    363 
    364 const XMLCh SchemaSymbols::fgATT_ABSTRACT[] =
    365 {
    366     chLatin_a, chLatin_b, chLatin_s, chLatin_t, chLatin_r, chLatin_a,
    367     chLatin_c, chLatin_t, chNull
    368 };
    369 
    370 const XMLCh SchemaSymbols::fgATT_ATTRIBUTEFORMDEFAULT[] =
    371 {
    372     chLatin_a, chLatin_t, chLatin_t, chLatin_r, chLatin_i, chLatin_b,
    373     chLatin_u, chLatin_t, chLatin_e, chLatin_F, chLatin_o, chLatin_r,
    374     chLatin_m, chLatin_D, chLatin_e, chLatin_f, chLatin_a, chLatin_u,
    375     chLatin_l, chLatin_t, chNull
    376 };
    377 
    378 const XMLCh SchemaSymbols::fgATT_BASE[] =
    379 {
    380     chLatin_b, chLatin_a, chLatin_s, chLatin_e,  chNull
    381 };
    382 
    383 const XMLCh SchemaSymbols::fgATT_ITEMTYPE[] =
    384 {
    385     chLatin_i, chLatin_t, chLatin_e, chLatin_m, chLatin_T, chLatin_y,
    386     chLatin_p, chLatin_e,  chNull
    387 };
    388 
    389 const XMLCh SchemaSymbols::fgATT_MEMBERTYPES[] =
    390 {
    391     chLatin_m, chLatin_e, chLatin_m, chLatin_b, chLatin_e, chLatin_r,
    392     chLatin_T, chLatin_y, chLatin_p, chLatin_e, chLatin_s, chNull
    393 };
    394 
    395 const XMLCh SchemaSymbols::fgATT_BLOCK[] =
    396 {
    397     chLatin_b, chLatin_l, chLatin_o, chLatin_c, chLatin_k,  chNull
    398 };
    399 
    400 const XMLCh SchemaSymbols::fgATT_BLOCKDEFAULT[] =
    401 {
    402     chLatin_b, chLatin_l, chLatin_o, chLatin_c, chLatin_k, chLatin_D,
    403     chLatin_e, chLatin_f, chLatin_a, chLatin_u, chLatin_l, chLatin_t, chNull
    404 };
    405 
    406 const XMLCh SchemaSymbols::fgATT_DEFAULT[] =
    407 {
    408     chLatin_d, chLatin_e, chLatin_f, chLatin_a, chLatin_u, chLatin_l, chLatin_t, chNull
    409 };
    410 
    411 const XMLCh SchemaSymbols::fgATT_ELEMENTFORMDEFAULT[] =
    412 {
    413     chLatin_e, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n,
    414     chLatin_t, chLatin_F, chLatin_o, chLatin_r, chLatin_m, chLatin_D,
    415     chLatin_e, chLatin_f, chLatin_a, chLatin_u, chLatin_l, chLatin_t, chNull
    416 };
    417 
    418 const XMLCh SchemaSymbols::fgATT_SUBSTITUTIONGROUP[] =
    419 {
    420     chLatin_s, chLatin_u, chLatin_b, chLatin_s, chLatin_t, chLatin_i,
    421     chLatin_t, chLatin_u, chLatin_t, chLatin_i, chLatin_o, chLatin_n,
    422     chLatin_G, chLatin_r, chLatin_o, chLatin_u, chLatin_p, chNull
    423 };
    424 
    425 const XMLCh SchemaSymbols::fgATT_FINAL[] =
    426 {
    427     chLatin_f, chLatin_i, chLatin_n, chLatin_a, chLatin_l, chNull
    428 };
    429 
    430 const XMLCh SchemaSymbols::fgATT_FINALDEFAULT[] =
    431 {
    432     chLatin_f, chLatin_i, chLatin_n, chLatin_a, chLatin_l, chLatin_D,
    433     chLatin_e, chLatin_f, chLatin_a, chLatin_u, chLatin_l, chLatin_t, chNull
    434 };
    435 
    436 const XMLCh SchemaSymbols::fgATT_FIXED[] =
    437 {
    438     chLatin_f, chLatin_i, chLatin_x, chLatin_e, chLatin_d,  chNull
    439 };
    440 
    441 const XMLCh SchemaSymbols::fgATT_FORM[] =
    442 {
    443     chLatin_f, chLatin_o, chLatin_r, chLatin_m, chNull
    444 };
    445 
    446 const XMLCh SchemaSymbols::fgATT_ID[] =
    447 {
    448     chLatin_i, chLatin_d, chNull
    449 };
    450 
    451 const XMLCh SchemaSymbols::fgATT_MAXOCCURS[] =
    452 {
    453     chLatin_m, chLatin_a, chLatin_x, chLatin_O, chLatin_c, chLatin_c,
    454     chLatin_u, chLatin_r, chLatin_s, chNull
    455 };
    456 
    457 const XMLCh SchemaSymbols::fgATT_MINOCCURS[] =
    458 {
    459     chLatin_m, chLatin_i, chLatin_n, chLatin_O, chLatin_c, chLatin_c,
    460     chLatin_u, chLatin_r, chLatin_s, chNull
    461 };
    462 
    463 const XMLCh SchemaSymbols::fgATT_NAME[] =
    464 {
    465     chLatin_n, chLatin_a, chLatin_m, chLatin_e, chNull
    466 };
    467 
    468 const XMLCh SchemaSymbols::fgATT_NAMESPACE[] =
    469 {
    470     chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chLatin_p,
    471     chLatin_a, chLatin_c, chLatin_e, chNull
    472 };
    473 
    474 const XMLCh SchemaSymbols::fgATT_NILL[] =
    475 {
    476     chLatin_n, chLatin_i, chLatin_l, chNull
    477 };
    478 
    479 const XMLCh SchemaSymbols::fgATT_NILLABLE[] =
    480 {
    481     chLatin_n, chLatin_i, chLatin_l, chLatin_l, chLatin_a, chLatin_b,
    482     chLatin_l, chLatin_e, chNull
    483 };
    484 
    485 const XMLCh SchemaSymbols::fgATT_PROCESSCONTENTS[] =
    486 {
    487     chLatin_p, chLatin_r, chLatin_o, chLatin_c, chLatin_e, chLatin_s,
    488     chLatin_s, chLatin_C, chLatin_o, chLatin_n, chLatin_t, chLatin_e,
    489     chLatin_n, chLatin_t, chLatin_s, chNull
    490 };
    491 
    492 const XMLCh SchemaSymbols::fgATT_REF[] =
    493 {
    494     chLatin_r, chLatin_e, chLatin_f, chNull
    495 };
    496 
    497 const XMLCh SchemaSymbols::fgATT_REFER[] =
    498 {
    499     chLatin_r, chLatin_e, chLatin_f, chLatin_e, chLatin_r, chNull
    500 };
    501 
    502 const XMLCh SchemaSymbols::fgATT_SCHEMALOCATION[] =
    503 {
    504     chLatin_s, chLatin_c, chLatin_h, chLatin_e, chLatin_m, chLatin_a,
    505     chLatin_L, chLatin_o, chLatin_c, chLatin_a, chLatin_t, chLatin_i,
    506     chLatin_o, chLatin_n, chNull
    507 };
    508 
    509 const XMLCh SchemaSymbols::fgATT_SOURCE[] =
    510 {
    511     chLatin_s, chLatin_o, chLatin_u, chLatin_r, chLatin_c, chLatin_e, chNull
    512 };
    513 
    514 const XMLCh SchemaSymbols::fgATT_SYSTEM[] =
    515 {
    516     chLatin_s, chLatin_y, chLatin_s, chLatin_t, chLatin_e, chLatin_m, chNull
    517 };
    518 
    519 const XMLCh SchemaSymbols::fgATT_PUBLIC[] =
    520 {
    521     chLatin_p, chLatin_u, chLatin_b, chLatin_l, chLatin_i, chLatin_c, chNull
    522 };
    523 
    524 const XMLCh SchemaSymbols::fgATT_TARGETNAMESPACE[] =
    525 {
    526     chLatin_t, chLatin_a, chLatin_r, chLatin_g, chLatin_e, chLatin_t,
    527     chLatin_N, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chLatin_p,
    528     chLatin_a, chLatin_c, chLatin_e, chNull
    529 };
    530 
    531 const XMLCh SchemaSymbols::fgATT_TYPE[] =
    532 {
    533     chLatin_t, chLatin_y, chLatin_p, chLatin_e, chNull
    534 };
    535 
    536 const XMLCh SchemaSymbols::fgATT_USE[] =
    537 {
    538     chLatin_u, chLatin_s, chLatin_e, chNull
    539 };
    540 
    541 const XMLCh SchemaSymbols::fgATT_VALUE[] =
    542 {
    543     chLatin_v, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
    544 };
    545 
    546 const XMLCh SchemaSymbols::fgATT_MIXED[] =
    547 {
    548     chLatin_m, chLatin_i, chLatin_x, chLatin_e, chLatin_d, chNull
    549 };
    550 
    551 const XMLCh SchemaSymbols::fgATT_VERSION[] =
    552 {
    553     chLatin_v, chLatin_e, chLatin_r, chLatin_s, chLatin_i,
    554     chLatin_o, chLatin_n, chNull
    555 };
    556 
    557 const XMLCh SchemaSymbols::fgATT_XPATH[] =
    558 {
    559     chLatin_x, chLatin_p, chLatin_a, chLatin_t, chLatin_h, chNull
    560 };
    561 
    562 const XMLCh SchemaSymbols::fgATTVAL_TWOPOUNDANY[] =
    563 {
    564     chPound, chPound, chLatin_a, chLatin_n, chLatin_y, chNull
    565 };
    566 
    567 const XMLCh SchemaSymbols::fgATTVAL_TWOPOUNDLOCAL[] =
    568 {
    569     chPound, chPound, chLatin_l, chLatin_o, chLatin_c, chLatin_a, chLatin_l, chNull
    570 };
    571 
    572 const XMLCh SchemaSymbols::fgATTVAL_TWOPOUNDOTHER[] =
    573 {
    574     chPound, chPound, chLatin_o, chLatin_t, chLatin_h, chLatin_e, chLatin_r, chNull
    575 };
    576 
    577 const XMLCh SchemaSymbols::fgATTVAL_TWOPOUNDTRAGETNAMESPACE[] =
    578 {
    579     chPound, chPound, chLatin_t, chLatin_a, chLatin_r, chLatin_g, chLatin_e,
    580     chLatin_t, chLatin_N, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chLatin_p,
    581     chLatin_a, chLatin_c, chLatin_e, chNull
    582 };
    583 
    584 const XMLCh SchemaSymbols::fgATTVAL_POUNDALL[] =
    585 {
    586     chPound, chLatin_a, chLatin_l, chLatin_l, chNull
    587 };
    588 
    589 const XMLCh SchemaSymbols::fgATTVAL_BASE64[] =
    590 {
    591     chLatin_b, chLatin_a, chLatin_s, chLatin_e, chDigit_6, chDigit_4, chNull
    592 };
    593 
    594 const XMLCh SchemaSymbols::fgATTVAL_BOOLEAN[] =
    595 {
    596     chLatin_b, chLatin_o, chLatin_o, chLatin_l, chLatin_e, chLatin_a, chLatin_n, chNull
    597 };
    598 
    599 const XMLCh SchemaSymbols::fgATTVAL_DEFAULT[] =
    600 {
    601     chLatin_d, chLatin_e, chLatin_f, chLatin_a, chLatin_u, chLatin_l, chLatin_t, chNull
    602 };
    603 
    604 const XMLCh SchemaSymbols::fgATTVAL_ELEMENTONLY[] =
    605 {
    606     chLatin_e, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n,
    607     chLatin_t, chLatin_O, chLatin_n, chLatin_l, chLatin_y, chNull
    608 };
    609 
    610 const XMLCh SchemaSymbols::fgATTVAL_EMPTY[] =
    611 {
    612     chLatin_e, chLatin_m, chLatin_p, chLatin_t, chLatin_y, chNull
    613 };
    614 
    615 const XMLCh SchemaSymbols::fgATTVAL_EXTENSION[] =
    616 {
    617     chLatin_e, chLatin_x, chLatin_t, chLatin_e, chLatin_n, chLatin_s,
    618     chLatin_i, chLatin_o, chLatin_n, chNull
    619 };
    620 
    621 const XMLCh SchemaSymbols::fgATTVAL_FALSE[] =
    622 {
    623     chLatin_f, chLatin_a, chLatin_l, chLatin_s, chLatin_e, chNull
    624 };
    625 
    626 const XMLCh SchemaSymbols::fgATTVAL_FIXED[] =
    627 {
    628     chLatin_f, chLatin_i, chLatin_x, chLatin_e, chLatin_d, chNull
    629 };
    630 
    631 const XMLCh SchemaSymbols::fgATTVAL_HEX[] =
    632 {
    633     chLatin_h, chLatin_e, chLatin_x, chNull
    634 };
    635 
    636 const XMLCh SchemaSymbols::fgATTVAL_ID[] =
    637 {
    638     chLatin_I, chLatin_D, chNull
    639 };
    640 
    641 const XMLCh SchemaSymbols::fgATTVAL_LAX[] =
    642 {
    643     chLatin_l, chLatin_a, chLatin_x, chNull
    644 };
    645 
    646 const XMLCh SchemaSymbols::fgATTVAL_MAXLENGTH[] =
    647 {
    648     chLatin_m, chLatin_a, chLatin_x, chLatin_L, chLatin_e, chLatin_n,
    649     chLatin_g, chLatin_t, chLatin_h, chNull
    650 };
    651 
    652 const XMLCh SchemaSymbols::fgATTVAL_MINLENGTH[] =
    653 {
    654     chLatin_m, chLatin_i, chLatin_n, chLatin_L, chLatin_e, chLatin_n,
    655     chLatin_g, chLatin_t, chLatin_h, chNull
    656 };
    657 
    658 
    659 const XMLCh SchemaSymbols::fgATTVAL_MIXED[] =
    660 {
    661     chLatin_m, chLatin_i, chLatin_x, chLatin_e, chLatin_d, chNull
    662 };
    663 
    664 
    665 const XMLCh SchemaSymbols::fgATTVAL_NCNAME[] =
    666 {
    667     chLatin_N, chLatin_C, chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
    668 };
    669 
    670 const XMLCh SchemaSymbols::fgATTVAL_OPTIONAL[] =
    671 {
    672     chLatin_o, chLatin_p, chLatin_t, chLatin_i, chLatin_o, chLatin_n,
    673     chLatin_a, chLatin_l, chNull
    674 };
    675 
    676 const XMLCh SchemaSymbols::fgATTVAL_PROHIBITED[] =
    677 {
    678     chLatin_p, chLatin_r, chLatin_o, chLatin_h, chLatin_i, chLatin_b,
    679     chLatin_i, chLatin_t, chLatin_e, chLatin_d, chNull
    680 };
    681 
    682 const XMLCh SchemaSymbols::fgATTVAL_QNAME[] =
    683 {
    684     chLatin_Q, chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
    685 };
    686 
    687 const XMLCh SchemaSymbols::fgATTVAL_QUALIFIED[] =
    688 {
    689     chLatin_q, chLatin_u, chLatin_a, chLatin_l, chLatin_i, chLatin_f,
    690     chLatin_i, chLatin_e, chLatin_d, chNull
    691 };
    692 
    693 const XMLCh SchemaSymbols::fgATTVAL_REQUIRED[] =
    694 {
    695     chLatin_r, chLatin_e, chLatin_q, chLatin_u, chLatin_i, chLatin_r,
    696     chLatin_e, chLatin_d, chNull
    697 };
    698 
    699 const XMLCh SchemaSymbols::fgATTVAL_RESTRICTION[] =
    700 {
    701     chLatin_r, chLatin_e, chLatin_s, chLatin_t, chLatin_r, chLatin_i,
    702     chLatin_c, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    703 };
    704 
    705 const XMLCh SchemaSymbols::fgATTVAL_SKIP[] =
    706 {
    707     chLatin_s, chLatin_k, chLatin_i, chLatin_p, chNull
    708 };
    709 
    710 const XMLCh SchemaSymbols::fgATTVAL_STRICT[] =
    711 {
    712     chLatin_s, chLatin_t, chLatin_r, chLatin_i, chLatin_c, chLatin_t, chNull
    713 };
    714 
    715 const XMLCh SchemaSymbols::fgATTVAL_STRING[] =
    716 {
    717     chLatin_s, chLatin_t, chLatin_r, chLatin_i, chLatin_n, chLatin_g, chNull
    718 };
    719 
    720 const XMLCh SchemaSymbols::fgATTVAL_TEXTONLY[] =
    721 {
    722     chLatin_t, chLatin_e, chLatin_x, chLatin_t, chLatin_O, chLatin_n,
    723     chLatin_l, chLatin_y, chNull
    724 };
    725 
    726 const XMLCh SchemaSymbols::fgATTVAL_TIMEDURATION[] =
    727 {
    728     chLatin_t, chLatin_i, chLatin_m, chLatin_e, chLatin_D, chLatin_u,
    729     chLatin_r, chLatin_a, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    730 };
    731 
    732 const XMLCh SchemaSymbols::fgATTVAL_TRUE[] =
    733 {
    734     chLatin_t, chLatin_r, chLatin_u, chLatin_e, chNull
    735 };
    736 
    737 const XMLCh SchemaSymbols::fgATTVAL_UNQUALIFIED[] =
    738 {
    739     chLatin_u, chLatin_n, chLatin_q, chLatin_u, chLatin_a, chLatin_l,
    740     chLatin_i, chLatin_f, chLatin_i, chLatin_e, chLatin_d, chNull
    741 };
    742 
    743 const XMLCh SchemaSymbols::fgATTVAL_URI[] =
    744 {
    745     chLatin_u, chLatin_r, chLatin_i, chNull
    746 };
    747 
    748 const XMLCh SchemaSymbols::fgATTVAL_URIREFERENCE[] =
    749 {
    750     chLatin_u, chLatin_r, chLatin_i, chLatin_R, chLatin_e, chLatin_f,
    751     chLatin_e, chLatin_r, chLatin_e, chLatin_n, chLatin_c, chLatin_e, chNull
    752 };
    753 
    754 const XMLCh SchemaSymbols::fgATTVAL_SUBSTITUTIONGROUP[] =
    755 {
    756     chLatin_s, chLatin_u, chLatin_b, chLatin_s, chLatin_t, chLatin_i,
    757     chLatin_t, chLatin_u, chLatin_t, chLatin_i, chLatin_o, chLatin_n,
    758     chLatin_G, chLatin_r, chLatin_o, chLatin_u, chLatin_p, chNull
    759 };
    760 
    761 const XMLCh SchemaSymbols::fgATTVAL_SUBSTITUTION[] =
    762 {
    763     chLatin_s, chLatin_u, chLatin_b, chLatin_s, chLatin_t, chLatin_i,
    764     chLatin_t, chLatin_u, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    765 };
    766 
    767 const XMLCh SchemaSymbols::fgATTVAL_ANYTYPE[] =
    768 {
    769     chLatin_a, chLatin_n, chLatin_y, chLatin_T, chLatin_y, chLatin_p,
    770     chLatin_e, chNull
    771 };
    772 
    773 const XMLCh SchemaSymbols::fgWS_PRESERVE[] =
    774 {
    775     chLatin_p, chLatin_r, chLatin_e, chLatin_s, chLatin_e, chLatin_r,
    776     chLatin_v, chLatin_e, chNull
    777 };
    778 
    779 const XMLCh SchemaSymbols::fgWS_COLLAPSE[] =
    780 {
    781     chLatin_c, chLatin_o, chLatin_l, chLatin_l, chLatin_a, chLatin_p,
    782     chLatin_s, chLatin_e, chNull
    783 };
    784 
    785 const XMLCh SchemaSymbols::fgWS_REPLACE[] =
    786 {
    787     chLatin_r, chLatin_e, chLatin_p, chLatin_l, chLatin_a, chLatin_c, chLatin_e, chNull
    788 };
    789 
    790 const XMLCh SchemaSymbols::fgDT_STRING[] =
    791 {
    792     chLatin_s, chLatin_t, chLatin_r, chLatin_i, chLatin_n, chLatin_g, chNull
    793 };
    794 
    795 const XMLCh SchemaSymbols::fgDT_TOKEN[] =
    796 {
    797     chLatin_t, chLatin_o, chLatin_k, chLatin_e, chLatin_n, chNull
    798 };
    799 
    800 const XMLCh SchemaSymbols::fgDT_LANGUAGE[] =
    801 {
    802     chLatin_l, chLatin_a, chLatin_n, chLatin_g, chLatin_u, chLatin_a,
    803     chLatin_g, chLatin_e, chNull
    804 };
    805 
    806 const XMLCh SchemaSymbols::fgDT_NAME[] =
    807 {
    808     chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
    809 };
    810 
    811 const XMLCh SchemaSymbols::fgDT_NCNAME[] =
    812 {
    813     chLatin_N, chLatin_C, chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
    814 };
    815 
    816 const XMLCh SchemaSymbols::fgDT_INTEGER[] =
    817 {
    818     chLatin_i, chLatin_n, chLatin_t, chLatin_e, chLatin_g, chLatin_e, chLatin_r, chNull
    819 };
    820 
    821 const XMLCh SchemaSymbols::fgDT_DECIMAL[] =
    822 {
    823     chLatin_d, chLatin_e, chLatin_c, chLatin_i, chLatin_m, chLatin_a, chLatin_l, chNull
    824 };
    825 
    826 const XMLCh SchemaSymbols::fgDT_BOOLEAN[] =
    827 {
    828     chLatin_b, chLatin_o, chLatin_o, chLatin_l, chLatin_e, chLatin_a, chLatin_n, chNull
    829 };
    830 
    831 const XMLCh SchemaSymbols::fgDT_NONPOSITIVEINTEGER[] =
    832 {
    833     chLatin_n, chLatin_o, chLatin_n, chLatin_P, chLatin_o, chLatin_s,
    834     chLatin_i, chLatin_t, chLatin_i, chLatin_v, chLatin_e, chLatin_I,
    835     chLatin_n, chLatin_t, chLatin_e, chLatin_g, chLatin_e, chLatin_r, chNull
    836 };
    837 
    838 const XMLCh SchemaSymbols::fgDT_NEGATIVEINTEGER[] =
    839 {
    840     chLatin_n, chLatin_e, chLatin_g, chLatin_a, chLatin_t, chLatin_i,
    841     chLatin_v, chLatin_e, chLatin_I, chLatin_n, chLatin_t, chLatin_e,
    842     chLatin_g, chLatin_e, chLatin_r, chNull
    843 };
    844 
    845 const XMLCh SchemaSymbols::fgDT_LONG[] =
    846 {
    847     chLatin_l, chLatin_o, chLatin_n, chLatin_g, chNull
    848 };
    849 
    850 const XMLCh SchemaSymbols::fgDT_INT[] =
    851 {
    852     chLatin_i, chLatin_n, chLatin_t, chNull
    853 };
    854 
    855 const XMLCh SchemaSymbols::fgDT_SHORT[] =
    856 {
    857     chLatin_s, chLatin_h, chLatin_o, chLatin_r, chLatin_t, chNull
    858 };
    859 
    860 const XMLCh SchemaSymbols::fgDT_BYTE[] =
    861 {
    862     chLatin_b, chLatin_y, chLatin_t, chLatin_e, chNull
    863 };
    864 
    865 const XMLCh SchemaSymbols::fgDT_NONNEGATIVEINTEGER[] =
    866 {
    867     chLatin_n, chLatin_o, chLatin_n, chLatin_N, chLatin_e, chLatin_g,
    868     chLatin_a, chLatin_t, chLatin_i, chLatin_v, chLatin_e, chLatin_I,
    869     chLatin_n, chLatin_t, chLatin_e, chLatin_g, chLatin_e, chLatin_r, chNull
    870 };
    871 
    872 const XMLCh SchemaSymbols::fgDT_ULONG[] =
    873 {
    874     chLatin_u, chLatin_n, chLatin_s, chLatin_i, chLatin_g, chLatin_n,
    875     chLatin_e, chLatin_d, chLatin_L, chLatin_o, chLatin_n, chLatin_g, chNull
    876 };
    877 
    878 const XMLCh SchemaSymbols::fgDT_UINT[] =
    879 {
    880     chLatin_u, chLatin_n, chLatin_s, chLatin_i, chLatin_g, chLatin_n,
    881     chLatin_e, chLatin_d, chLatin_I, chLatin_n, chLatin_t, chNull
    882 };
    883 
    884 const XMLCh SchemaSymbols::fgDT_USHORT[] =
    885 {
    886     chLatin_u, chLatin_n, chLatin_s, chLatin_i, chLatin_g, chLatin_n, chLatin_e,
    887         chLatin_d, chLatin_S, chLatin_h, chLatin_o, chLatin_r, chLatin_t, chNull
    888 };
    889 
    890 const XMLCh SchemaSymbols::fgDT_UBYTE[] =
    891 {
    892     chLatin_u, chLatin_n, chLatin_s, chLatin_i, chLatin_g, chLatin_n,
    893     chLatin_e, chLatin_d, chLatin_B, chLatin_y, chLatin_t, chLatin_e, chNull
    894 };
    895 
    896 const XMLCh SchemaSymbols::fgDT_POSITIVEINTEGER[] =
    897 {
    898     chLatin_p, chLatin_o, chLatin_s, chLatin_i, chLatin_t, chLatin_i,
    899     chLatin_v, chLatin_e, chLatin_I, chLatin_n, chLatin_t, chLatin_e,
    900     chLatin_g, chLatin_e, chLatin_r, chNull
    901 };
    902 
    903 const XMLCh SchemaSymbols::fgDT_DATETIME[] =
    904 {
    905     chLatin_d, chLatin_a, chLatin_t, chLatin_e,
    906     chLatin_T, chLatin_i, chLatin_m, chLatin_e, chNull
    907 };
    908 
    909 const XMLCh SchemaSymbols::fgDT_DATE[] =
    910 {
    911     chLatin_d, chLatin_a, chLatin_t, chLatin_e, chNull
    912 };
    913 
    914 const XMLCh SchemaSymbols::fgDT_TIME[] =
    915 {
    916     chLatin_t, chLatin_i, chLatin_m, chLatin_e, chNull
    917 };
    918 
    919 const XMLCh SchemaSymbols::fgDT_DURATION[] =
    920 {
    921     chLatin_d, chLatin_u, chLatin_r, chLatin_a,
    922     chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
    923 };
    924 
    925 const XMLCh SchemaSymbols::fgDT_DAY[] =
    926 {
    927     chLatin_g, chLatin_D, chLatin_a, chLatin_y, chNull
    928 };
    929 
    930 const XMLCh SchemaSymbols::fgDT_MONTH[] =
    931 {
    932     chLatin_g, chLatin_M, chLatin_o, chLatin_n, chLatin_t, chLatin_h, chNull
    933 };
    934 
    935 const XMLCh SchemaSymbols::fgDT_MONTHDAY[] =
    936 {
    937     chLatin_g, chLatin_M, chLatin_o, chLatin_n, chLatin_t, chLatin_h,
    938     chLatin_D, chLatin_a, chLatin_y, chNull
    939 };
    940 
    941 const XMLCh SchemaSymbols::fgDT_YEAR[] =
    942 {
    943     chLatin_g, chLatin_Y, chLatin_e, chLatin_a, chLatin_r, chNull
    944 };
    945 
    946 const XMLCh SchemaSymbols::fgDT_YEARMONTH[] =
    947 {
    948     chLatin_g, chLatin_Y, chLatin_e, chLatin_a, chLatin_r,
    949     chLatin_M, chLatin_o, chLatin_n, chLatin_t, chLatin_h, chNull
    950 };
    951 
    952 const XMLCh SchemaSymbols::fgDT_BASE64BINARY[] =
    953 {
    954     chLatin_b, chLatin_a, chLatin_s, chLatin_e, chDigit_6, chDigit_4,
    955     chLatin_B, chLatin_i, chLatin_n, chLatin_a, chLatin_r, chLatin_y, chNull
    956 };
    957 
    958 const XMLCh SchemaSymbols::fgDT_HEXBINARY[] =
    959 {
    960     chLatin_h, chLatin_e, chLatin_x,
    961     chLatin_B, chLatin_i, chLatin_n, chLatin_a, chLatin_r, chLatin_y, chNull
    962 };
    963 
    964 const XMLCh SchemaSymbols::fgDT_FLOAT[] =
    965 {
    966     chLatin_f, chLatin_l, chLatin_o, chLatin_a, chLatin_t, chNull
    967 };
    968 
    969 const XMLCh SchemaSymbols::fgDT_DOUBLE[] =
    970 {
    971     chLatin_d, chLatin_o, chLatin_u, chLatin_b, chLatin_l, chLatin_e, chNull
    972 };
    973 
    974 const XMLCh SchemaSymbols::fgDT_URIREFERENCE[] =
    975 {
    976     chLatin_u, chLatin_r, chLatin_i, chLatin_R, chLatin_e, chLatin_f,
    977     chLatin_e, chLatin_r, chLatin_e, chLatin_n, chLatin_c, chLatin_e, chNull
    978 };
    979 
    980 const XMLCh SchemaSymbols::fgDT_ANYURI[] =
    981 {
    982     chLatin_a, chLatin_n, chLatin_y, chLatin_U, chLatin_R, chLatin_I, chNull
    983 };
    984 
    985 const XMLCh SchemaSymbols::fgDT_QNAME[] =
    986 {
    987     chLatin_Q, chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
    988 };
    989 
    990 const XMLCh SchemaSymbols::fgDT_NORMALIZEDSTRING[] =
    991 {
    992     chLatin_n, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_l, chLatin_i,
    993     chLatin_z, chLatin_e, chLatin_d, chLatin_S, chLatin_t, chLatin_r, chLatin_i,
    994     chLatin_n, chLatin_g, chNull
    995 };
    996 
    997 const XMLCh SchemaSymbols::fgDT_ANYSIMPLETYPE[] =
    998 {
    999     chLatin_a, chLatin_n, chLatin_y, chLatin_S, chLatin_i, chLatin_m, chLatin_p,
    1000     chLatin_l, chLatin_e, chLatin_T, chLatin_y, chLatin_p, chLatin_e, chNull
    1001 };
    1002 
    1003 const XMLCh SchemaSymbols::fgRegEx_XOption[] =
    1004 {
    1005     chLatin_X, chNull
    1006 };
    1007 
    1008 const XMLCh SchemaSymbols::fgRedefIdentifier[] =
    1009 {
    1010     chUnderscore, chLatin_r, chLatin_d, chLatin_f, chLatin_n, chNull
    1011 };
    1012 
    1013 const int SchemaSymbols::fgINT_MIN_VALUE = 0x80000000;
    1014 
    1015 const int SchemaSymbols::fgINT_MAX_VALUE = 0x7fffffff;
    1016 
    1017 XERCES_CPP_NAMESPACE_END
    1018 
    1019 /**
    1020   * End of file SchemaSymbols.cpp
    1021   */
    1022 
     1#include <icxercesc/validators/schema/SchemaSymbols.cpp>
  • icXML/icXML-devel/src/xercesc/validators/schema/SchemaSymbols.hpp

    r2722 r2747  
    1 /*
    2  * Licensed to the Apache Software Foundation (ASF) under one or more
    3  * contributor license agreements.  See the NOTICE file distributed with
    4  * this work for additional information regarding copyright ownership.
    5  * The ASF licenses this file to You under the Apache License, Version 2.0
    6  * (the "License"); you may not use this file except in compliance with
    7  * the License.  You may obtain a copy of the License at
    8  *
    9  *      http://www.apache.org/licenses/LICENSE-2.0
    10  *
    11  * Unless required by applicable law or agreed to in writing, software
    12  * distributed under the License is distributed on an "AS IS" BASIS,
    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  * See the License for the specific language governing permissions and
    15  * limitations under the License.
    16  */
    17 
    18 /*
    19  * $Id: SchemaSymbols.hpp 802804 2009-08-10 14:21:48Z amassari $
    20  */
    21 
    22 #if !defined(XERCESC_INCLUDE_GUARD_SCHEMASYMBOLS_HPP)
    23 #define XERCESC_INCLUDE_GUARD_SCHEMASYMBOLS_HPP
    24 
    25 #include <xercesc/util/XercesDefs.hpp>
    26 
    27 XERCES_CPP_NAMESPACE_BEGIN
    28 
    29 /*
    30  * Collection of symbols used to parse a Schema Grammar
    31  */
    32 
    33 class VALIDATORS_EXPORT SchemaSymbols
    34 {
    35 public :
    36     // -----------------------------------------------------------------------
    37     // Constant data
    38     // -----------------------------------------------------------------------
    39     static const XMLCh fgURI_XSI[];
    40     static const XMLCh fgURI_SCHEMAFORSCHEMA[];
    41     // deprecated (typo)
    42     static const XMLCh fgXSI_SCHEMALOCACTION[];
    43     // deprecated (typo)
    44     static const XMLCh fgXSI_NONAMESPACESCHEMALOCACTION[];
    45     static const XMLCh fgXSI_SCHEMALOCATION[];
    46     static const XMLCh fgXSI_NONAMESPACESCHEMALOCATION[];
    47     static const XMLCh fgXSI_TYPE[];
    48     static const XMLCh fgELT_ALL[];
    49     static const XMLCh fgELT_ANNOTATION[];
    50     static const XMLCh fgELT_ANY[];
    51     static const XMLCh fgELT_WILDCARD[];
    52     static const XMLCh fgELT_ANYATTRIBUTE[];
    53     static const XMLCh fgELT_APPINFO[];
    54     static const XMLCh fgELT_ATTRIBUTE[];
    55     static const XMLCh fgELT_ATTRIBUTEGROUP[];
    56     static const XMLCh fgELT_CHOICE[];
    57     static const XMLCh fgELT_COMPLEXTYPE[];
    58     static const XMLCh fgELT_CONTENT[];
    59     static const XMLCh fgELT_DOCUMENTATION[];
    60     static const XMLCh fgELT_DURATION[];
    61     static const XMLCh fgELT_ELEMENT[];
    62     static const XMLCh fgELT_ENCODING[];
    63     static const XMLCh fgELT_ENUMERATION[];
    64     static const XMLCh fgELT_FIELD[];
    65     static const XMLCh fgELT_WHITESPACE[];
    66     static const XMLCh fgELT_GROUP[];
    67     static const XMLCh fgELT_IMPORT[];
    68     static const XMLCh fgELT_INCLUDE[];
    69     static const XMLCh fgELT_REDEFINE[];
    70     static const XMLCh fgELT_KEY[];
    71     static const XMLCh fgELT_KEYREF[];
    72     static const XMLCh fgELT_LENGTH[];
    73     static const XMLCh fgELT_MAXEXCLUSIVE[];
    74     static const XMLCh fgELT_MAXINCLUSIVE[];
    75     static const XMLCh fgELT_MAXLENGTH[];
    76     static const XMLCh fgELT_MINEXCLUSIVE[];
    77     static const XMLCh fgELT_MININCLUSIVE[];
    78     static const XMLCh fgELT_MINLENGTH[];
    79     static const XMLCh fgELT_NOTATION[];
    80     static const XMLCh fgELT_PATTERN[];
    81     static const XMLCh fgELT_PERIOD[];
    82     static const XMLCh fgELT_TOTALDIGITS[];
    83     static const XMLCh fgELT_FRACTIONDIGITS[];
    84     static const XMLCh fgELT_SCHEMA[];
    85     static const XMLCh fgELT_SELECTOR[];
    86     static const XMLCh fgELT_SEQUENCE[];
    87     static const XMLCh fgELT_SIMPLETYPE[];
    88     static const XMLCh fgELT_UNION[];
    89     static const XMLCh fgELT_LIST[];
    90     static const XMLCh fgELT_UNIQUE[];
    91     static const XMLCh fgELT_COMPLEXCONTENT[];
    92     static const XMLCh fgELT_SIMPLECONTENT[];
    93     static const XMLCh fgELT_RESTRICTION[];
    94     static const XMLCh fgELT_EXTENSION[];
    95     static const XMLCh fgATT_ABSTRACT[];
    96     static const XMLCh fgATT_ATTRIBUTEFORMDEFAULT[];
    97     static const XMLCh fgATT_BASE[];
    98     static const XMLCh fgATT_ITEMTYPE[];
    99     static const XMLCh fgATT_MEMBERTYPES[];
    100     static const XMLCh fgATT_BLOCK[];
    101     static const XMLCh fgATT_BLOCKDEFAULT[];
    102     static const XMLCh fgATT_DEFAULT[];
    103     static const XMLCh fgATT_ELEMENTFORMDEFAULT[];
    104     static const XMLCh fgATT_SUBSTITUTIONGROUP[];
    105     static const XMLCh fgATT_FINAL[];
    106     static const XMLCh fgATT_FINALDEFAULT[];
    107     static const XMLCh fgATT_FIXED[];
    108     static const XMLCh fgATT_FORM[];
    109     static const XMLCh fgATT_ID[];
    110     static const XMLCh fgATT_MAXOCCURS[];
    111     static const XMLCh fgATT_MINOCCURS[];
    112     static const XMLCh fgATT_NAME[];
    113     static const XMLCh fgATT_NAMESPACE[];
    114     static const XMLCh fgATT_NILL[];
    115     static const XMLCh fgATT_NILLABLE[];
    116     static const XMLCh fgATT_PROCESSCONTENTS[];
    117     static const XMLCh fgATT_REF[];
    118     static const XMLCh fgATT_REFER[];
    119     static const XMLCh fgATT_SCHEMALOCATION[];
    120     static const XMLCh fgATT_SOURCE[];
    121     static const XMLCh fgATT_SYSTEM[];
    122     static const XMLCh fgATT_PUBLIC[];
    123     static const XMLCh fgATT_TARGETNAMESPACE[];
    124     static const XMLCh fgATT_TYPE[];
    125     static const XMLCh fgATT_USE[];
    126     static const XMLCh fgATT_VALUE[];
    127     static const XMLCh fgATT_MIXED[];
    128     static const XMLCh fgATT_VERSION[];
    129     static const XMLCh fgATT_XPATH[];
    130     static const XMLCh fgATTVAL_TWOPOUNDANY[];
    131     static const XMLCh fgATTVAL_TWOPOUNDLOCAL[];
    132     static const XMLCh fgATTVAL_TWOPOUNDOTHER[];
    133     static const XMLCh fgATTVAL_TWOPOUNDTRAGETNAMESPACE[];
    134     static const XMLCh fgATTVAL_POUNDALL[];
    135     static const XMLCh fgATTVAL_BASE64[];
    136     static const XMLCh fgATTVAL_BOOLEAN[];
    137     static const XMLCh fgATTVAL_DEFAULT[];
    138     static const XMLCh fgATTVAL_ELEMENTONLY[];
    139     static const XMLCh fgATTVAL_EMPTY[];
    140     static const XMLCh fgATTVAL_EXTENSION[];
    141     static const XMLCh fgATTVAL_FALSE[];
    142     static const XMLCh fgATTVAL_FIXED[];
    143     static const XMLCh fgATTVAL_HEX[];
    144     static const XMLCh fgATTVAL_ID[];
    145     static const XMLCh fgATTVAL_LAX[];
    146     static const XMLCh fgATTVAL_MAXLENGTH[];
    147     static const XMLCh fgATTVAL_MINLENGTH[];
    148     static const XMLCh fgATTVAL_MIXED[];
    149     static const XMLCh fgATTVAL_NCNAME[];
    150     static const XMLCh fgATTVAL_OPTIONAL[];
    151     static const XMLCh fgATTVAL_PROHIBITED[];
    152     static const XMLCh fgATTVAL_QNAME[];
    153     static const XMLCh fgATTVAL_QUALIFIED[];
    154     static const XMLCh fgATTVAL_REQUIRED[];
    155     static const XMLCh fgATTVAL_RESTRICTION[];
    156     static const XMLCh fgATTVAL_SKIP[];
    157     static const XMLCh fgATTVAL_STRICT[];
    158     static const XMLCh fgATTVAL_STRING[];
    159     static const XMLCh fgATTVAL_TEXTONLY[];
    160     static const XMLCh fgATTVAL_TIMEDURATION[];
    161     static const XMLCh fgATTVAL_TRUE[];
    162     static const XMLCh fgATTVAL_UNQUALIFIED[];
    163     static const XMLCh fgATTVAL_URI[];
    164     static const XMLCh fgATTVAL_URIREFERENCE[];
    165     static const XMLCh fgATTVAL_SUBSTITUTIONGROUP[];
    166     static const XMLCh fgATTVAL_SUBSTITUTION[];
    167     static const XMLCh fgATTVAL_ANYTYPE[];
    168     static const XMLCh fgWS_PRESERVE[];
    169     static const XMLCh fgWS_COLLAPSE[];
    170     static const XMLCh fgWS_REPLACE[];
    171     static const XMLCh fgDT_STRING[];
    172     static const XMLCh fgDT_TOKEN[];
    173     static const XMLCh fgDT_LANGUAGE[];
    174     static const XMLCh fgDT_NAME[];
    175     static const XMLCh fgDT_NCNAME[];
    176     static const XMLCh fgDT_INTEGER[];
    177     static const XMLCh fgDT_DECIMAL[];
    178     static const XMLCh fgDT_BOOLEAN[];
    179     static const XMLCh fgDT_NONPOSITIVEINTEGER[];
    180     static const XMLCh fgDT_NEGATIVEINTEGER[];
    181     static const XMLCh fgDT_LONG[];
    182     static const XMLCh fgDT_INT[];
    183     static const XMLCh fgDT_SHORT[];
    184     static const XMLCh fgDT_BYTE[];
    185         static const XMLCh fgDT_NONNEGATIVEINTEGER[];
    186     static const XMLCh fgDT_ULONG[];
    187     static const XMLCh fgDT_UINT[];
    188         static const XMLCh fgDT_USHORT[];
    189         static const XMLCh fgDT_UBYTE[];
    190     static const XMLCh fgDT_POSITIVEINTEGER[];
    191 //datetime
    192     static const XMLCh fgDT_DATETIME[];
    193     static const XMLCh fgDT_DATE[];
    194         static const XMLCh fgDT_TIME[];
    195     static const XMLCh fgDT_DURATION[];
    196     static const XMLCh fgDT_DAY[];
    197     static const XMLCh fgDT_MONTH[];
    198     static const XMLCh fgDT_MONTHDAY[];
    199     static const XMLCh fgDT_YEAR[];
    200     static const XMLCh fgDT_YEARMONTH[];
    201 
    202     static const XMLCh fgDT_BASE64BINARY[];
    203     static const XMLCh fgDT_HEXBINARY[];
    204     static const XMLCh fgDT_FLOAT[];
    205     static const XMLCh fgDT_DOUBLE[];
    206     static const XMLCh fgDT_URIREFERENCE[];
    207     static const XMLCh fgDT_ANYURI[];
    208     static const XMLCh fgDT_QNAME[];
    209     static const XMLCh fgDT_NORMALIZEDSTRING[];
    210     static const XMLCh fgDT_ANYSIMPLETYPE[];
    211     static const XMLCh fgRegEx_XOption[];
    212     static const XMLCh fgRedefIdentifier[];
    213     static const int   fgINT_MIN_VALUE;
    214     static const int   fgINT_MAX_VALUE;
    215 
    216     enum {
    217         XSD_EMPTYSET = 0,
    218         XSD_SUBSTITUTION = 1,
    219         XSD_EXTENSION = 2,
    220         XSD_RESTRICTION = 4,
    221         XSD_LIST = 8,
    222         XSD_UNION = 16,
    223         XSD_ENUMERATION = 32
    224     };
    225 
    226     // group orders
    227     enum {
    228         XSD_CHOICE = 0,
    229         XSD_SEQUENCE= 1,
    230         XSD_ALL = 2
    231     };
    232 
    233     enum {
    234         XSD_UNBOUNDED = -1,
    235         XSD_NILLABLE = 1,
    236         XSD_ABSTRACT = 2,
    237         XSD_FIXED = 4
    238     };
    239 
    240 private:
    241     // -----------------------------------------------------------------------
    242     //  Unimplemented constructors and operators
    243     // -----------------------------------------------------------------------
    244     SchemaSymbols();
    245 };
    246 
    247 XERCES_CPP_NAMESPACE_END
    248 
    249 #endif
    250 
    251 /**
    252   * End of file SchemaSymbols.hpp
    253   */
    254 
     1#include <icxercesc/validators/schema/SchemaSymbols.hpp>
  • icXML/icXML-devel/src/xercesc/validators/schema/SchemaValidator.cpp

    r2734 r2747  
    1 /*
    2  * Licensed to the Apache Software Foundation (ASF) under one or more
    3  * contributor license agreements.  See the NOTICE file distributed with
    4  * this work for additional information regarding copyright ownership.
    5  * The ASF licenses this file to You under the Apache License, Version 2.0
    6  * (the "License"); you may not use this file except in compliance with
    7  * the License.  You may obtain a copy of the License at
    8  *
    9  *      http://www.apache.org/licenses/LICENSE-2.0
    10  *
    11  * Unless required by applicable law or agreed to in writing, software
    12  * distributed under the License is distributed on an "AS IS" BASIS,
    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  * See the License for the specific language governing permissions and
    15  * limitations under the License.
    16  */
    17 
    18 /*
    19  * $Id: SchemaValidator.cpp 806488 2009-08-21 10:36:58Z amassari $
    20  */
    21 
    22 // ---------------------------------------------------------------------------
    23 //  Includes
    24 // ---------------------------------------------------------------------------
    25 #include <xercesc/util/Janitor.hpp>
    26 #include <xercesc/framework/XMLDocumentHandler.hpp>
    27 #include <xercesc/framework/XMLSchemaDescription.hpp>
    28 #include <xercesc/framework/psvi/XSAnnotation.hpp>
    29 #include <icxercesc/internal/XMLReader.hpp>
    30 #include <icxercesc/internal/XMLScanner.hpp>
    31 #include <icxercesc/internal/ElemStack.hpp>
    32 #include <icxercesc/validators/datatype/DatatypeValidatorFactory.hpp>
    33 #include <xercesc/validators/datatype/ListDatatypeValidator.hpp>
    34 #include <xercesc/validators/datatype/UnionDatatypeValidator.hpp>
    35 #include <xercesc/validators/datatype/ENTITYDatatypeValidator.hpp>
    36 #include <xercesc/validators/datatype/IDDatatypeValidator.hpp>
    37 #include <xercesc/validators/datatype/IDREFDatatypeValidator.hpp>
    38 #include <icxercesc/validators/schema/SchemaSymbols.hpp>
    39 #include <icxercesc/validators/schema/SchemaValidator.hpp>
    40 #include <icxercesc/validators/schema/SubstitutionGroupComparator.hpp>
    41 #include <xercesc/validators/schema/XercesGroupInfo.hpp>
    42 #include <xercesc/validators/schema/XSDLocator.hpp>
    43 #include <xercesc/util/OutOfMemoryException.hpp>
    44 
    45 XERCES_CPP_NAMESPACE_BEGIN
    46 
    47 // ---------------------------------------------------------------------------
    48 //  SchemaValidator: Constructors and Destructor
    49 // ---------------------------------------------------------------------------
    50 SchemaValidator::SchemaValidator( XMLErrorReporter* const errReporter
    51                                 , MemoryManager* const    manager) :
    52 
    53     XMLValidator(errReporter)
    54     , fMemoryManager(manager)
    55     , fSchemaGrammar(0)
    56     , fGrammarResolver(0)
    57     , fXsiType(0)
    58     , fNil(false)
    59     , fNilFound(false)
    60     , fCurrentDatatypeValidator(0)
    61     , fNotationBuf(0)
    62     , fDatatypeBuffer(1023, manager)
    63     , fTrailing(false)
    64     , fSeenNonWhiteSpace(false)
    65     , fSeenId(false)
    66     , fTypeStack(0)
    67     , fMostRecentAttrValidator(0)
    68     , fErrorOccurred(false)
    69     , fElemIsSpecified(false)
    70 {
    71     fTypeStack = new (fMemoryManager) ValueStackOf<ComplexTypeInfo*>(8, fMemoryManager);
    72 }
    73 
    74 SchemaValidator::~SchemaValidator()
    75 {
    76     delete fXsiType;
    77     delete fTypeStack;
    78 
    79     if (fNotationBuf)
    80         delete fNotationBuf;
    81 }
    82 
    83 // ---------------------------------------------------------------------------
    84 //  SchemaValidator: Implementation of the XMLValidator interface
    85 // ---------------------------------------------------------------------------
    86 bool SchemaValidator::checkContent (XMLElementDecl* const elemDecl
    87                                  , QName** const          children
    88                                  , XMLSize_t              childCount
    89                                  , XMLSize_t*             indexFailingChild)
    90 {
    91     fErrorOccurred = false;
    92     fElemIsSpecified = false;
    93 
    94     //
    95     //  Look up the element id in our element decl pool. This will get us
    96     //  the element decl in our own way of looking at them.
    97     //
    98     if (!elemDecl)
    99         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Val_InvalidElemId, fMemoryManager);
    100 
    101     //
    102     //  Get the content spec type of this element. This will tell us what
    103     //  to do to validate it.
    104     //
    105     // the top of the type stack always knows best...
    106     ComplexTypeInfo* currType = fTypeStack->pop();
    107 
    108     const SchemaElementDecl::ModelTypes modelType = (currType)
    109             ? (SchemaElementDecl::ModelTypes)(currType->getContentType())
    110             : ((SchemaElementDecl*)elemDecl)->getModelType();
    111 
    112     if (modelType == SchemaElementDecl::Empty  ||
    113         modelType == SchemaElementDecl::ElementOnlyEmpty)
    114     {
    115         //
    116         //  We can do this one here. It cannot have any children. If it does
    117         //  we return 0 as the index of the first bad child.
    118         //
    119         if (childCount) {
    120             fErrorOccurred = true;
    121             *indexFailingChild=0;
    122             return false;
    123         }
    124     }
    125     else if ((modelType == SchemaElementDecl::Mixed_Simple)
    126          ||  (modelType == SchemaElementDecl::Mixed_Complex)
    127          ||  (modelType == SchemaElementDecl::Children))
    128     {
    129         // if nillable, it's an error to have value
    130         // XML Schema REC: Validation Rule: Element Locally Valid (Element)
    131         // 3.2.1 The element information item must have no
    132         // character or element information item [children].
    133         //
    134         if (fNil) {
    135             if (childCount > 0 || !XMLString::equals(fDatatypeBuffer.getRawBuffer(), XMLUni::fgZeroLenString)) {
    136                 emitError(XMLValid::NilAttrNotEmpty, elemDecl->getFullName());
    137                 fErrorOccurred = true;
    138             }
    139         }
    140         else {
    141             // Get the element's content model or fault it in
    142             XMLContentModel* elemCM = (currType)
    143                     ? currType->getContentModel()
    144                     : ((SchemaElementDecl*)elemDecl)->getContentModel();
    145 
    146             // Ask it to validate and return its return
    147             unsigned int emptyNS = getScanner()->getEmptyNamespaceId();
    148             bool result = elemCM->validateContent(children, childCount, emptyNS, indexFailingChild, getScanner()->getMemoryManager());
    149             if (!result) {
    150                 result = elemCM->validateContentSpecial(children
    151                                                       , childCount
    152                                                       , emptyNS
    153                                                       , fGrammarResolver
    154                                                       , fGrammarResolver->getStringPool()
    155                                                       , indexFailingChild
    156                                                                                                           , getScanner()->getMemoryManager());
    157             }
    158 
    159             if(!result) {
    160                 fErrorOccurred = true;
    161             }
    162 
    163             return result;
    164         }
    165     }
    166     else if (modelType == SchemaElementDecl::Simple || modelType == SchemaElementDecl::Any)
    167     {
    168         // Normally for SchemaElementDecl::Any, We pass no judgement on it and anything goes
    169         // but if there is a fXsiTypeValidator, we need to use it for validation
    170         if (modelType == SchemaElementDecl::Simple && childCount > 0) {
    171             emitError(XMLValid::SimpleTypeHasChild, elemDecl->getFullName());
    172             fErrorOccurred = true;
    173         }
    174         else
    175         {
    176             XMLCh* value = fDatatypeBuffer.getRawBuffer();
    177             XMLCh* elemDefaultValue = ((SchemaElementDecl*) elemDecl)->getDefaultValue();
    178 
    179             if (fNil)
    180             {
    181                 if ((!XMLString::equals(value, XMLUni::fgZeroLenString))
    182                     || elemDefaultValue)
    183                 {
    184                     emitError(XMLValid::NilAttrNotEmpty, elemDecl->getFullName());
    185                     fErrorOccurred = true;
    186                 }
    187             }
    188                         else if (fCurrentDatatypeValidator)
    189             {
    190                 DatatypeValidator::ValidatorType eleDefDVType = fCurrentDatatypeValidator->getType();
    191                 bool validateCanonical = false;
    192                 if (eleDefDVType == DatatypeValidator::NOTATION)
    193                 {
    194                     // if notation, need to bind URI to notation first
    195                     if (!fNotationBuf)
    196                         fNotationBuf = new (fMemoryManager) XMLBuffer(1023, fMemoryManager);
    197 
    198                     //  Make sure that this value maps to one of the
    199                     //  notation values in the enumList parameter. We don't have to
    200                     //  look it up in the notation pool (if a notation) because we
    201                     //  will look up the enumerated values themselves. If they are in
    202                     //  the notation pool (after the Grammar is parsed), then obviously
    203                     //  this value will be legal since it matches one of them.
    204                     int colonPos = -1;
    205                     unsigned int uriId = getScanner()->resolveQName(value, *fNotationBuf, ElemStack::Mode_Element, colonPos);
    206 
    207                     const XMLCh* uriText = getScanner()->getURIText(uriId);
    208                     if (uriText && *uriText) {
    209                         fNotationBuf->set(uriText);
    210                         fNotationBuf->append(chColon);
    211                         fNotationBuf->append(&value[colonPos + 1]);
    212                         value = fNotationBuf->getRawBuffer();
    213                     }
    214                 }
    215 
    216                 if (elemDefaultValue)
    217                 {
    218                     if (XMLString::equals(value, XMLUni::fgZeroLenString))
    219                     {
    220                         fElemIsSpecified = true;
    221                         // if this element didn't specified any value
    222                         // use default value
    223                         if (getScanner()->getDocHandler())
    224                             getScanner()->getDocHandler()->docCharacters(elemDefaultValue, XMLString::stringLen(elemDefaultValue), false);
    225 
    226                         // Normally for default value, it has been validated already during TraverseSchema
    227                         // But if there was a xsi:type and this validator is fXsiTypeValidator,
    228                         // need to validate again
    229                         // we determine this if the current content dataype validator
    230                         // is neither the one in the element nor the one in the current
    231                         // complex type (if any)
    232                         if ((fCurrentDatatypeValidator != ((SchemaElementDecl*)elemDecl)->getDatatypeValidator())
    233                             && (!fTypeStack->peek() || (fCurrentDatatypeValidator != fTypeStack->peek()->getDatatypeValidator()))) {
    234                             value = elemDefaultValue;
    235                             validateCanonical = true;
    236                         }
    237                         else
    238                             value = 0;
    239                     }
    240                     else
    241                     {
    242                         // this element has specified some value
    243                         // if the flag is FIXED, then this value must be same as default value
    244                         if ((((SchemaElementDecl*)elemDecl)->getMiscFlags() & SchemaSymbols::XSD_FIXED) != 0)
    245                         {
    246                             if (fCurrentDatatypeValidator->compare(value, elemDefaultValue, fMemoryManager) != 0 )
    247                             {
    248                                 emitError(XMLValid::FixedDifferentFromActual, elemDecl->getFullName());
    249                                 fErrorOccurred = true;
    250                             }
    251                         }
    252                     }
    253                 }
    254 
    255                 if ((!fErrorOccurred) && value)
    256                 {
    257                     try {
    258                         fCurrentDatatypeValidator->validate(value, getScanner()->getValidationContext(), fMemoryManager);
    259                         if (validateCanonical) {
    260                             XMLCh* canonical = (XMLCh*) fCurrentDatatypeValidator->getCanonicalRepresentation(value, fMemoryManager);
    261                             ArrayJanitor<XMLCh> tempCanonical(canonical, fMemoryManager);
    262                             fCurrentDatatypeValidator->validate(canonical, getScanner()->getValidationContext(), fMemoryManager);
    263                         }
    264                     }
    265                     catch (XMLException& idve)
    266                     {
    267                         emitError (XMLValid::DatatypeError, idve.getCode(), idve.getMessage());
    268                         fErrorOccurred = true;
    269                     }
    270                     catch(const OutOfMemoryException&) {
    271                         throw;
    272                     }
    273                     catch (...)
    274                     {
    275                         emitError(XMLValid::GenericError);
    276                         throw;
    277                     }
    278                 }
    279             }
    280             else if (modelType == SchemaElementDecl::Simple)
    281             {
    282                 emitError(XMLValid::NoDatatypeValidatorForSimpleType, elemDecl->getFullName());
    283                 fErrorOccurred = true;
    284             }
    285             // modelType is any
    286             else if (elemDefaultValue)
    287             {
    288                 if (XMLString::equals(value, XMLUni::fgZeroLenString))
    289                 {
    290                     fElemIsSpecified = true;
    291                     // if this element didn't specified any value
    292                     // use default value
    293                     if (getScanner()->getDocHandler()) {
    294                         getScanner()->getDocHandler()->docCharacters(elemDefaultValue, XMLString::stringLen(elemDefaultValue), false);
    295                     }
    296                 }
    297             }
    298         }
    299     }
    300     else
    301     {
    302         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMType, fMemoryManager);
    303     }
    304 
    305     // must rely on scanner to clear fDatatypeBuffer
    306     // since it may need to query its contents after this method completes
    307     fNil = false;
    308     fNilFound = false;
    309     fTrailing=false;
    310     fSeenNonWhiteSpace = false;
    311     fCurrentDatatypeValidator = 0;
    312 
    313     // Went ok, so return success
    314     return true;
    315 }
    316 
    317 void SchemaValidator::faultInAttr (XMLAttr&    toFill, const XMLAttDef&  attDef)   const
    318 {
    319     //
    320     //  At this level, we cannot set the URI id. So we just set it to zero
    321     //  and leave it at that. The scanner, who called us, will look at the
    322     //  prefix we stored (if any), resolve it, and store the URL id if any.
    323     //
    324     SchemaAttDef* schemaAttDef = (SchemaAttDef*) &attDef;
    325     QName* attName = schemaAttDef->getAttName();
    326 
    327     toFill.set
    328     (
    329           attName->getURI()
    330         , attName->getLocalPart()
    331         , attName->getPrefix()
    332         , schemaAttDef->getValue()
    333         , schemaAttDef->getType()
    334     );
    335 }
    336 
    337 void SchemaValidator::reset()
    338 {
    339     fTrailing = false;
    340     fSeenNonWhiteSpace = false;
    341     fSeenId = false;
    342         fTypeStack->removeAllElements();
    343     delete fXsiType;
    344     fXsiType = 0;
    345     fCurrentDatatypeValidator = 0;
    346     fNil = false;
    347     fNilFound = false;
    348     fDatatypeBuffer.reset();
    349     fErrorOccurred = false;
    350 }
    351 
    352 bool SchemaValidator::requiresNamespaces() const
    353 {
    354     return true;
    355 }
    356 
    357 void SchemaValidator::validateAttrValue (const XMLAttDef*      attDef
    358                                        , const XMLCh* const    attrValue
    359                                        , bool                  preValidation
    360                                        , const XMLElementDecl* elemDecl)
    361 {
    362     fErrorOccurred = false;
    363 
    364     //turn on IdRefList checking
    365     getScanner()->getValidationContext()->toCheckIdRefList(true);
    366 
    367     //
    368     //  Get quick refs to lot of the stuff in the passed objects in
    369     //  order to simplify the code below, which will reference them very
    370     //  often.
    371     //
    372     XMLAttDef::AttTypes            type      = attDef->getType();
    373     const XMLAttDef::DefAttTypes   defType   = attDef->getDefaultType();
    374 
    375     //
    376     //  If the default type is fixed, then make sure the passed value maps
    377     //  to the fixed value.
    378     //
    379     //  If during preContentValidation, the value we are validating is the fixed value itself
    380     //  so no need to compare.
    381     //  Only need to do this for regular attribute value validation
    382     //
    383     if ((defType == XMLAttDef::Fixed || defType == XMLAttDef::Required_And_Fixed) && !preValidation)
    384     {
    385         const XMLCh* const valueText = attDef->getValue();
    386         if (!XMLString::equals(attrValue, valueText)) {
    387             emitError(XMLValid::NotSameAsFixedValue, attDef->getFullName(), attrValue, valueText);
    388             fErrorOccurred = true;
    389         }
    390     }
    391 
    392     // An empty string cannot be valid for non_CDATA any of the other types
    393     if (!attrValue[0] && type != XMLAttDef::Simple)
    394     {
    395         emitError(XMLValid::InvalidEmptyAttValue, attDef->getFullName());
    396         // accords with original DOMTypeInfo implementation, but this does not feel right.
    397         fMostRecentAttrValidator = DatatypeValidatorFactory::getBuiltInRegistry()->get(SchemaSymbols::fgDT_ANYSIMPLETYPE);
    398         fErrorOccurred = true;
    399         return;
    400     }
    401 
    402     DatatypeValidator* attDefDV = ((SchemaAttDef*) attDef)->getDatatypeValidator();
    403     if (!attDefDV) {
    404         emitError(XMLValid::NoDatatypeValidatorForAttribute, attDef->getFullName());
    405         fErrorOccurred = true;
    406     }
    407     else {
    408         DatatypeValidator::ValidatorType attDefDVType = attDefDV->getType();
    409         ValidationContext *context = getScanner()->getValidationContext();
    410         try {
    411 
    412             // first, if notation, need to bind URI to notation first
    413             if (attDefDVType == DatatypeValidator::NOTATION)
    414             {
    415                 //
    416                 //  Make sure that this value maps to one of the
    417                 //  notation values in the enumList parameter. We don't have to
    418                 //  look it up in the notation pool (if a notation) because we
    419                 //  will look up the enumerated values themselves. If they are in
    420                 //  the notation pool (after the Grammar is parsed), then obviously
    421                 //  this value will be legal since it matches one of them.
    422                 //
    423                 XMLBuffer notationBuf(1023, fMemoryManager);
    424                 int colonPos = -1;
    425                 unsigned int uriId = getScanner()->resolveQName(attrValue, notationBuf, ElemStack::Mode_Element, colonPos);
    426                 const XMLCh* uriText = getScanner()->getURIText(uriId);
    427                 if (uriText && *uriText) {
    428                     notationBuf.set(uriText);
    429                     notationBuf.append(chColon);
    430                     notationBuf.append(&attrValue[colonPos + 1]);
    431                 }
    432                 else {
    433                     notationBuf.set(attrValue);
    434                 }
    435 
    436                 attDefDV->validate(notationBuf.getRawBuffer()
    437                                  , context
    438                                  , fMemoryManager);
    439             }
    440             else {
    441                 attDefDV->validate(attrValue
    442                                  , context
    443                                  , fMemoryManager);
    444             }
    445 
    446         }
    447         catch (XMLException& idve) {
    448             fErrorOccurred = true;
    449             emitError (XMLValid::DatatypeError, idve.getCode(), idve.getMessage());
    450         }
    451         catch(const OutOfMemoryException&)
    452         {
    453             throw;
    454         }
    455         catch (...) {
    456             emitError(XMLValid::GenericError);
    457             fMostRecentAttrValidator = DatatypeValidatorFactory::getBuiltInRegistry()->get(SchemaSymbols::fgDT_ANYSIMPLETYPE);
    458             fErrorOccurred = true;
    459             throw;
    460         }
    461         fMostRecentAttrValidator = attDefDV;
    462         // now we can look for ID's, entities, ...
    463 
    464         // set up the entitydeclpool in ENTITYDatatypeValidator
    465         // and the idreflist in ID/IDREFDatatypeValidator
    466 
    467         // indicate if this attribute is of type ID
    468         bool thisIsAnId = false;
    469 
    470         if (attDefDVType == DatatypeValidator::List) {
    471             DatatypeValidator* itemDTV = ((ListDatatypeValidator*)attDefDV)->getItemTypeDTV();
    472             DatatypeValidator::ValidatorType itemDTVType = itemDTV->getType();
    473             if (itemDTVType == DatatypeValidator::ID) {
    474                 thisIsAnId = true;
    475             }
    476             else if (itemDTVType == DatatypeValidator::IDREF) {
    477                 // if in prevalidatoin, do not add attDef to IDREFList
    478                 if (preValidation)
    479                     //todo: when to setIdRefList back to non-null
    480                     getScanner()->getValidationContext()->toCheckIdRefList(false);
    481             }
    482         }
    483         else if (attDefDVType == DatatypeValidator::Union) {
    484             DatatypeValidator *memberDTV = context->getValidatingMemberType();
    485             // actual type for DOMTypeInfo is memberDTV
    486             fMostRecentAttrValidator = memberDTV;
    487             // no member datatype validator if there was an error
    488             if(memberDTV)
    489             {
    490                 DatatypeValidator::ValidatorType memberDTVType = memberDTV->getType();
    491                 if (memberDTVType == DatatypeValidator::ID) {
    492                     thisIsAnId = true;
    493                 }
    494                 else if (memberDTVType == DatatypeValidator::IDREF) {
    495                     // if in prevalidatoin, do not add attDef to IDREFList
    496                     if (preValidation)
    497                         getScanner()->getValidationContext()->toCheckIdRefList(false);
    498                 }
    499             }
    500         }
    501         else if (attDefDVType == DatatypeValidator::ID) {
    502             thisIsAnId = true;
    503         }
    504         else if (attDefDVType == DatatypeValidator::IDREF) {
    505             // if in prevalidation, do not add attDef to IDREFList
    506             if (preValidation)
    507                 getScanner()->getValidationContext()->toCheckIdRefList(false);
    508         }
    509         if (thisIsAnId) {
    510             if (fSeenId) {
    511                 emitError
    512                 (
    513                     XMLValid::MultipleIdAttrs
    514                     , elemDecl->getFullName()
    515                 );
    516                 fErrorOccurred = true;
    517             }
    518             else
    519                 fSeenId = true;
    520         }
    521 
    522     }
    523 
    524     if(fErrorOccurred) {
    525         fMostRecentAttrValidator = DatatypeValidatorFactory::getBuiltInRegistry()->get(SchemaSymbols::fgDT_ANYSIMPLETYPE);
    526     }
    527     fTrailing = false;
    528     fSeenNonWhiteSpace = false;
    529 }
    530 
    531 void SchemaValidator::validateElement(const   XMLElementDecl*  elemDef)
    532 {
    533     ComplexTypeInfo* elemTypeInfo = ((SchemaElementDecl*)elemDef)->getComplexTypeInfo();
    534     fTypeStack->push(elemTypeInfo);
    535     fCurrentDatatypeValidator = (elemTypeInfo)
    536             ? elemTypeInfo->getDatatypeValidator()
    537             : ((SchemaElementDecl*)elemDef)->getDatatypeValidator();
    538 
    539     fErrorOccurred = false;
    540 
    541     if (fXsiType) {
    542         // handle "xsi:type" right here
    543         DatatypeValidator *xsiTypeDV = 0;
    544         unsigned int uri = fXsiType->getURI();
    545         const XMLCh* localPart = fXsiType->getLocalPart();
    546 
    547         if (uri != XMLElementDecl::fgInvalidElemId &&
    548             uri != XMLElementDecl::fgPCDataElemId &&
    549             uri != XMLContentModel::gEpsilonFakeId &&
    550             uri != XMLContentModel::gEOCFakeId) {
    551 
    552             // retrieve Grammar for the uri
    553             const XMLCh* uriStr = getScanner()->getURIText(uri);
    554             SchemaGrammar* sGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(uriStr);
    555             if (!sGrammar) {
    556 
    557                 // Check built-in simple types
    558                 if (XMLString::equals(uriStr, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) {
    559 
    560                     xsiTypeDV = fGrammarResolver->getDatatypeValidator(uriStr, localPart);
    561 
    562                     if (!xsiTypeDV) {
    563                         emitError(XMLValid::BadXsiType, fXsiType->getRawName());
    564                         fErrorOccurred = true;
    565                     }
    566                     else {
    567                         if (elemTypeInfo || (fCurrentDatatypeValidator
    568                                 && !fCurrentDatatypeValidator->isSubstitutableBy(xsiTypeDV))) {
    569                             // the type is not derived from ancestor
    570                             emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
    571                             fErrorOccurred = true;
    572                         }
    573                         else if(fCurrentDatatypeValidator != xsiTypeDV)
    574                         {
    575                             // the type is derived from ancestor
    576                             if ((((SchemaElementDecl*)elemDef)->getBlockSet() & SchemaSymbols::XSD_RESTRICTION) != 0) {
    577                                 emitError(XMLValid::ElemNoSubforBlock, elemDef->getFullName());
    578                                 fErrorOccurred = true;
    579                             }
    580                             if (elemDef->hasAttDefs()) {
    581                                 // if we have an attribute but xsi:type's type is simple, we have a problem...
    582                                 emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
    583                                 fErrorOccurred = true;
    584                             }
    585                         }
    586                         fCurrentDatatypeValidator = xsiTypeDV;
    587                     }
    588                 }
    589                 else {
    590                     // Grammar not found
    591                     emitError(XMLValid::GrammarNotFound, uriStr);
    592                     fErrorOccurred = true;
    593                 }
    594             }
    595             else if (sGrammar->getGrammarType() != Grammar::SchemaGrammarType) {
    596                 emitError(XMLValid::GrammarNotFound, uriStr);
    597                 fErrorOccurred = true;
    598             }
    599             else {
    600                 // retrieve complexType registry and DatatypeValidator registry
    601                 RefHashTableOf<ComplexTypeInfo>* complexTypeRegistry = sGrammar->getComplexTypeRegistry();
    602                 if (!complexTypeRegistry) {
    603                     emitError(XMLValid::BadXsiType, fXsiType->getRawName());
    604                     fErrorOccurred = true;
    605                 }
    606                 else {
    607 
    608                     // retrieve the typeInfo specified in xsi:type
    609                     XMLBuffer aBuffer(1023, fMemoryManager);
    610                     aBuffer.set(uriStr);
    611                     aBuffer.append(chComma);
    612                     aBuffer.append(localPart);
    613                     ComplexTypeInfo* typeInfo = complexTypeRegistry->get(aBuffer.getRawBuffer());
    614 
    615                     if (typeInfo) {
    616                         // typeInfo is found
    617                         if (typeInfo->getAbstract()) {
    618                             emitError(XMLValid::NoAbstractInXsiType, aBuffer.getRawBuffer());
    619                             fErrorOccurred = true;
    620                         }
    621                         else
    622                         {
    623                             if (elemTypeInfo)
    624                             {
    625                                 ComplexTypeInfo* tempType = typeInfo;
    626                                 while (tempType) {
    627                                     if (tempType == elemTypeInfo)
    628                                         break;
    629                                     tempType = tempType->getBaseComplexTypeInfo();
    630                                 }
    631 
    632                                 if (!tempType) {
    633                                     emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
    634                                     fErrorOccurred = true;
    635                                 }
    636                                 else if(elemTypeInfo != typeInfo) {
    637                                     // perform the check on the entire inheritance chain
    638                                     ComplexTypeInfo* tempType = typeInfo;
    639                                     while (tempType) {
    640                                         if (tempType == elemTypeInfo)
    641                                             break;
    642                                         int derivationMethod = tempType->getDerivedBy();
    643                                         if ((((SchemaElementDecl*)elemDef)->getBlockSet() & derivationMethod) != 0) {
    644                                             emitError(XMLValid::ElemNoSubforBlock, elemDef->getFullName());
    645                                             fErrorOccurred = true;
    646                                         }
    647                                         if ((elemTypeInfo->getBlockSet() & derivationMethod) != 0) {
    648                                             emitError(XMLValid::TypeNoSubforBlock, elemTypeInfo->getTypeName());
    649                                             fErrorOccurred = true;
    650                                         }
    651                                         tempType = tempType->getBaseComplexTypeInfo();
    652                                     }
    653                                 }
    654                             }
    655                             else
    656                             {
    657                                 // if the original type is a simple type, check derivation ok.
    658                                 if (fCurrentDatatypeValidator && !fCurrentDatatypeValidator->isSubstitutableBy(typeInfo->getDatatypeValidator())) {
    659                                     // the type is not derived from ancestor
    660                                     emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
    661                                     fErrorOccurred = true;
    662                                 }
    663                             }
    664 
    665                             if (!fErrorOccurred)
    666                             {
    667                                 fTypeStack->pop();
    668                                 fTypeStack->push(typeInfo);
    669                                 fCurrentDatatypeValidator = typeInfo->getDatatypeValidator();
    670                             }
    671                         }
    672                     }
    673                     else
    674                     {
    675                         // typeInfo not found
    676                         xsiTypeDV = fGrammarResolver->getDatatypeValidator(uriStr, localPart);
    677 
    678                         if (!xsiTypeDV) {
    679                             emitError(XMLValid::BadXsiType, fXsiType->getRawName());
    680                             fErrorOccurred = true;
    681                         }
    682                         else {
    683                             if (fCurrentDatatypeValidator && !fCurrentDatatypeValidator->isSubstitutableBy(xsiTypeDV)) {
    684                                 // the type is not derived from ancestor
    685                                 emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
    686                                 fErrorOccurred = true;
    687                             }
    688                             else if(fCurrentDatatypeValidator != xsiTypeDV)
    689                             {
    690                                 DatatypeValidator::ValidatorType derivedType=xsiTypeDV->getType();
    691                                 if((derivedType == DatatypeValidator::List || derivedType == DatatypeValidator::Union) && fCurrentDatatypeValidator==0)
    692                                 {
    693                                     // the substitution is always allowed if the type is list or union and the base type was xs:anySimpleType
    694                                 }
    695                                 else
    696                                 {
    697                                     // the type is derived from ancestor
    698                                     if ((((SchemaElementDecl*)elemDef)->getBlockSet() & SchemaSymbols::XSD_RESTRICTION) != 0) {
    699                                         emitError(XMLValid::ElemNoSubforBlock, elemDef->getFullName());
    700                                         fErrorOccurred = true;
    701                                     }
    702                                     if (elemDef->hasAttDefs()) {
    703                                         // if we have an attribute but xsi:type's type is simple, we have a problem...
    704                                         emitError(XMLValid::NonDerivedXsiType, fXsiType->getRawName(), elemDef->getFullName());
    705                                         fErrorOccurred = true;
    706                                     }
    707                                 }
    708                             }
    709 
    710                             fCurrentDatatypeValidator = xsiTypeDV;
    711                         }
    712                     }
    713                 }
    714             }
    715         }
    716 
    717         delete fXsiType;
    718         fXsiType = 0;
    719     }
    720     else {
    721         //
    722         // xsi:type was not specified...
    723         // If the corresponding type is abstract, detect an error
    724         //
    725         if (elemTypeInfo && elemTypeInfo->getAbstract()) {
    726             emitError(XMLValid::NoUseAbstractType, elemDef->getFullName());
    727             fErrorOccurred = true;
    728         }
    729     }
    730 
    731     //
    732     // Check whether this element is abstract.  If so, an error
    733     //
    734     int miscFlags = ((SchemaElementDecl*)elemDef)->getMiscFlags();
    735     if ((miscFlags & SchemaSymbols::XSD_ABSTRACT) != 0) {
    736         emitError(XMLValid::NoDirectUseAbstractElement, elemDef->getFullName());
    737         fErrorOccurred = true;
    738     }
    739 
    740     //
    741     // Check whether this element allows Nillable
    742     //
    743     if (fNilFound && (miscFlags & SchemaSymbols::XSD_NILLABLE) == 0 ) {
    744         fNil = false;
    745         fNilFound = false;
    746         emitError(XMLValid::NillNotAllowed, elemDef->getFullName());
    747         fErrorOccurred = true;
    748     }
    749 
    750     fDatatypeBuffer.reset();
    751     fTrailing = false;
    752     fSeenNonWhiteSpace = false;
    753     fSeenId = false;
    754 }
    755 
    756 void SchemaValidator::preContentValidation(bool,
    757                                            bool validateDefAttr)
    758 {
    759     //  Lets go through all the grammar in the GrammarResolver
    760     //    and validate those that has not been validated yet
    761     //
    762     //  Lets enumerate all of the elements in the element decl pool
    763     //    and put out an error for any that did not get declared.
    764     //    We also check all of the attributes as well.
    765     //
    766     //  And enumerate all the complextype info in the grammar
    767     //    and do Unique Particle Attribution Checking
    768 
    769     RefHashTableOfEnumerator<Grammar> grammarEnum = fGrammarResolver->getGrammarEnumerator();
    770     while (grammarEnum.hasMoreElements())
    771     {
    772         SchemaGrammar& sGrammar = (SchemaGrammar&) grammarEnum.nextElement();
    773         if (sGrammar.getGrammarType() != Grammar::SchemaGrammarType || sGrammar.getValidated())
    774              continue;
    775 
    776         sGrammar.setValidated(true);
    777 
    778         RefHash3KeysIdPoolEnumerator<SchemaElementDecl> elemEnum = sGrammar.getElemEnumerator();
    779 
    780         while (elemEnum.hasMoreElements())
    781         {
    782             SchemaElementDecl& curElem = elemEnum.nextElement();
    783 
    784             //  First check if declared or not
    785             //
    786             //  See if this element decl was ever marked as declared. If
    787             //  not, then put out an error. In some cases its just
    788             //  a warning, such as being referenced in a content model.
    789             //
    790             const SchemaElementDecl::CreateReasons reason = curElem.getCreateReason();
    791 
    792             if (reason != XMLElementDecl::Declared)
    793             {
    794                 if (reason == XMLElementDecl::AttList)
    795                 {
    796                     getScanner()->emitError
    797                     (
    798                         XMLErrs::UndeclaredElemInAttList
    799                         , curElem.getFullName()
    800                     );
    801                 }
    802                  else if (reason == XMLElementDecl::AsRootElem)
    803                 {
    804                     emitError
    805                     (
    806                         XMLValid::UndeclaredElemInDocType
    807                         , curElem.getFullName()
    808                     );
    809                 }
    810                  else if (reason == XMLElementDecl::InContentModel)
    811                 {
    812                     getScanner()->emitError
    813                     (
    814                         XMLErrs::UndeclaredElemInCM
    815                         , curElem.getFullName()
    816                     );
    817                 }
    818                 else
    819                 {
    820                 }
    821             }
    822 
    823             //
    824             //  Then check all of the attributes of the current element.
    825             //  We check for:
    826             //
    827             //  1) Multiple ID attributes
    828             //  2) That all of the default values of attributes are
    829             //      valid for their type.
    830             //  3) That for any notation types, that their lists
    831             //      of possible values refer to declared notations.
    832             //
    833             if (curElem.hasAttDefs()) {
    834                 XMLAttDefList& attDefList = curElem.getAttDefList();
    835                 bool seenId = false;
    836 
    837                 for(XMLSize_t i=0; i<attDefList.getAttDefCount(); i++)
    838                 {
    839                     const XMLAttDef& curAttDef = attDefList.getAttDef(i);
    840 
    841                     if (curAttDef.getType() == XMLAttDef::ID)
    842                     {
    843                         if (seenId)
    844                         {
    845                             emitError
    846                             (
    847                                 XMLValid::MultipleIdAttrs
    848                                 , curElem.getFullName()
    849                             );
    850                             break;
    851                         }
    852 
    853                         seenId = true;
    854                     }
    855                      else if (curAttDef.getType() == XMLAttDef::Notation && curAttDef.getEnumeration())
    856                     {
    857                         //
    858                         //  We need to verify that all of its possible values
    859                         //  (in the enum list) refer to valid notations.
    860                         //
    861                         XMLCh* list = XMLString::replicate(curAttDef.getEnumeration(), fMemoryManager);
    862                         ArrayJanitor<XMLCh> janList(list, fMemoryManager);
    863 
    864                         //
    865                         //  Search forward for a space or a null. If a null,
    866                         //  we are done. If a space, cap it and look it up.
    867                         //
    868                         bool    breakFlag = false;
    869                         XMLCh*  listPtr = list;
    870                         XMLCh*  lastPtr = listPtr;
    871                         while (true)
    872                         {
    873                             while (*listPtr && (*listPtr != chSpace))
    874                                 listPtr++;
    875 
    876                             //
    877                             //  If at the end, indicate we need to break after
    878                             //  this one. Else, cap it off here.
    879                             //
    880                             if (!*listPtr)
    881                                 breakFlag = true;
    882                             else
    883                                 *listPtr = chNull;
    884 
    885                             if (!sGrammar.getNotationDecl(lastPtr))
    886                             {
    887                                 emitError
    888                                 (
    889                                     XMLValid::UnknownNotRefAttr
    890                                     , curAttDef.getFullName()
    891                                     , lastPtr
    892                                 );
    893                             }
    894 
    895                             // Break out if we hit the end last time
    896                             if (breakFlag)
    897                                 break;
    898 
    899                             // Else move upwards and try again
    900                             listPtr++;
    901                             lastPtr = listPtr;
    902                         }
    903                     }
    904 
    905                     // If it has a default/fixed value, then validate it
    906                     if (validateDefAttr && curAttDef.getValue())
    907                     {
    908                         validateAttrValue
    909                         (
    910                             &curAttDef
    911                             , curAttDef.getValue()
    912                             , true
    913                             , &curElem
    914                         );
    915                     }
    916                 }
    917             }
    918         }
    919 
    920         //  For each complex type info, check the Unique Particle Attribution
    921         if (getScanner()->getValidationSchemaFullChecking()) {
    922             RefHashTableOf<ComplexTypeInfo>* complexTypeRegistry = sGrammar.getComplexTypeRegistry();
    923 
    924             RefHashTableOfEnumerator<ComplexTypeInfo> complexTypeEnum(complexTypeRegistry, false, fMemoryManager);
    925             while (complexTypeEnum.hasMoreElements())
    926             {
    927                 ComplexTypeInfo& curTypeInfo = complexTypeEnum.nextElement();
    928                 curTypeInfo.checkUniqueParticleAttribution(&sGrammar, fGrammarResolver, fGrammarResolver->getStringPool(), this);
    929                 checkParticleDerivation(&sGrammar, &curTypeInfo);
    930                 checkRefElementConsistency(&sGrammar, &curTypeInfo);
    931             }
    932 
    933             RefHashTableOf<XercesGroupInfo>* groupInfoRegistry = sGrammar.getGroupInfoRegistry();
    934             RefHashTableOfEnumerator<XercesGroupInfo> groupEnum(groupInfoRegistry, false, fMemoryManager);
    935 
    936             while (groupEnum.hasMoreElements()) {
    937 
    938                 XercesGroupInfo& curGroup = groupEnum.nextElement();
    939                 XercesGroupInfo* baseGroup = curGroup.getBaseGroup();
    940 
    941                 if (baseGroup) {
    942                     try {
    943                         checkParticleDerivationOk(&sGrammar, curGroup.getContentSpec(), curGroup.getScope(),
    944                                                   baseGroup->getContentSpec(), baseGroup->getScope());
    945                     }
    946                     catch (const XMLException& excep) {
    947                         fSchemaErrorReporter.emitError(excep, curGroup.getLocator());
    948                                         }
    949                 }
    950 
    951                 if (curGroup.getCheckElementConsistency())
    952                     checkRefElementConsistency(&sGrammar, 0, &curGroup);
    953             }
    954         }
    955     }
    956 }
    957 
    958 void SchemaValidator::postParseValidation()
    959 {
    960     //
    961     //  At this time, there is nothing to do here. The scanner itself handles
    962     //  ID/IDREF validation, since that is the same no matter what kind of
    963     //  validator.
    964     //
    965 }
    966 
    967 // ---------------------------------------------------------------------------
    968 //  SchemaValidator: Validator method
    969 // ---------------------------------------------------------------------------
    970 // Do Schema Normalization depends on the WhiteSpace Facet
    971 // preserve : No normalization is done
    972 // replace  : All occurrences of #x9 (tab), #xA (linefeed) and #xD (carriage return)
    973 //            are replaced with #x20 (space).
    974 // collapse : Subsequent to the replacements specified above under replace,
    975 //            contiguous sequences of #x20s are collapsed to a single #x20,
    976 //            and initial and/or final #x20s are deleted.
    977 //
    978 void SchemaValidator::normalizeWhiteSpace(DatatypeValidator* dV, const XMLCh* const value, XMLBuffer& toFill, bool bStandalone /*= false*/)
    979 {
    980     toFill.reset();
    981 
    982     //empty string
    983     if (!*value)
    984         return;
    985 
    986     if(bStandalone)
    987         fTrailing = fSeenNonWhiteSpace = false;
    988 
    989     short wsFacet = dV->getWSFacet();
    990 
    991     //  Loop through the chars of the source value and normalize it
    992     //  according to the whitespace facet
    993     XMLCh nextCh;
    994     const XMLCh* srcPtr = value;
    995     XMLReader* fCurReader = getReaderMgr()->getCurrentReader();
    996 
    997     if (wsFacet == DatatypeValidator::REPLACE)
    998     {
    999         while (*srcPtr)
    1000         {
    1001             nextCh = *srcPtr++;
    1002             if (fCurReader->isWhitespace(nextCh))
    1003                 nextCh = chSpace;
    1004             // Add this char to the target buffer
    1005             toFill.append(nextCh);
    1006         }
    1007     }
    1008     else // COLLAPSE
    1009     {
    1010         enum States
    1011         {
    1012             InWhitespace
    1013             , InContent
    1014         };
    1015 
    1016         States curState = fTrailing ? InWhitespace : InContent;
    1017         while (*srcPtr)
    1018         {
    1019             nextCh = *srcPtr++;
    1020             if (curState == InContent)
    1021             {
    1022                 if (fCurReader->isWhitespace(nextCh))
    1023                 {
    1024                     curState = InWhitespace;
    1025                     continue;
    1026                 }
    1027                 fSeenNonWhiteSpace = true;
    1028             }
    1029             else if (curState == InWhitespace)
    1030             {
    1031                 if (fCurReader->isWhitespace(nextCh))
    1032                     continue;
    1033                 if (fSeenNonWhiteSpace)
    1034                     toFill.append(chSpace);
    1035                 curState = InContent;
    1036                 fSeenNonWhiteSpace = true;
    1037             }
    1038             // Add this char to the target buffer
    1039             toFill.append(nextCh);
    1040         }
    1041 
    1042         if (fCurReader->isWhitespace(*(srcPtr-1)))
    1043           fTrailing = true;
    1044         else
    1045           fTrailing = false;
    1046     }
    1047     if(bStandalone)
    1048         fTrailing = fSeenNonWhiteSpace = false;
    1049 }
    1050 
    1051 
    1052 // ---------------------------------------------------------------------------
    1053 //  SchemaValidator: Particle Derivation Checking
    1054 // ---------------------------------------------------------------------------
    1055 void SchemaValidator::checkRefElementConsistency(SchemaGrammar* const currentGrammar,
    1056                                                  const ComplexTypeInfo* const curTypeInfo,
    1057                                                  const XercesGroupInfo* const curGroup) {
    1058 
    1059     XMLSize_t elemCount = (curTypeInfo) ? curTypeInfo->elementCount() : curGroup->elementCount();
    1060     int elemScope = (curTypeInfo) ? curTypeInfo->getScopeDefined() : curGroup->getScope();
    1061     XSDLocator* typeInfoLocator = (curTypeInfo) ? curTypeInfo->getLocator() : curGroup->getLocator();
    1062 
    1063     for (XMLSize_t i=0; i < elemCount; i++) {
    1064 
    1065         const SchemaElementDecl* elemDecl = (curTypeInfo) ? curTypeInfo->elementAt(i) : curGroup->elementAt(i);
    1066 
    1067         if (elemDecl->isGlobalDecl()) {
    1068 
    1069             unsigned int elemURI = elemDecl->getURI();
    1070             const XMLCh* elemName = elemDecl->getBaseName();
    1071             const SchemaElementDecl* other = (SchemaElementDecl*)
    1072                 currentGrammar->getElemDecl(elemURI, elemName, 0, elemScope);
    1073 
    1074             if (other
    1075                 && (elemDecl->getComplexTypeInfo() != other->getComplexTypeInfo() ||
    1076                     elemDecl->getDatatypeValidator() != other->getDatatypeValidator())) {
    1077                 fSchemaErrorReporter.emitError(XMLErrs::DuplicateElementDeclaration,
    1078                                                XMLUni::fgXMLErrDomain, typeInfoLocator, elemName, 0, 0, 0, fMemoryManager);
    1079                 continue;
    1080             }
    1081 
    1082             RefHash2KeysTableOf<ElemVector>* validSubsGroups = currentGrammar->getValidSubstitutionGroups();
    1083             ValueVectorOf<SchemaElementDecl*>* subsElements = validSubsGroups->get(elemName, elemURI);
    1084 
    1085             if (subsElements) {
    1086 
    1087                 XMLSize_t subsElemSize = subsElements->size();
    1088 
    1089                 for (XMLSize_t j=0; j < subsElemSize; j++) {
    1090 
    1091                     SchemaElementDecl* subsElem = subsElements->elementAt(j);
    1092                     const XMLCh* subsElemName = subsElem->getBaseName();
    1093                     other = (SchemaElementDecl*)
    1094                         currentGrammar->getElemDecl(subsElem->getURI(), subsElemName, 0, elemScope);
    1095 
    1096                     if (other
    1097                         && (subsElem->getComplexTypeInfo() != other->getComplexTypeInfo()
    1098                             || subsElem->getDatatypeValidator() != other->getDatatypeValidator())) {
    1099                         fSchemaErrorReporter.emitError(XMLErrs::DuplicateElementDeclaration,
    1100                                                        XMLUni::fgXMLErrDomain, typeInfoLocator, elemName, 0, 0, 0, fMemoryManager);
    1101                     }
    1102                 }
    1103             }
    1104         }
    1105     }
    1106 }
    1107 
    1108 // ---------------------------------------------------------------------------
    1109 //  SchemaValidator: Particle Derivation Checking
    1110 // ---------------------------------------------------------------------------
    1111 void SchemaValidator::checkParticleDerivation(SchemaGrammar* const currentGrammar,
    1112                                               const ComplexTypeInfo* const curTypeInfo) {
    1113 
    1114     ComplexTypeInfo* baseTypeInfo = 0;
    1115     ContentSpecNode* curSpecNode = 0;
    1116 
    1117     if (curTypeInfo->getDerivedBy() == SchemaSymbols::XSD_RESTRICTION
    1118         && ((baseTypeInfo = curTypeInfo->getBaseComplexTypeInfo()) != 0)
    1119         && ((curSpecNode = curTypeInfo->getContentSpec()) != 0)) {
    1120 
    1121         try {
    1122             checkParticleDerivationOk(currentGrammar, curSpecNode,
    1123                                       curTypeInfo->getScopeDefined(),
    1124                                       baseTypeInfo->getContentSpec(),
    1125                                       baseTypeInfo->getScopeDefined(), baseTypeInfo);
    1126         }
    1127         catch (const XMLException& excep) {
    1128             fSchemaErrorReporter.emitError(excep, curTypeInfo->getLocator());
    1129         }
    1130     }
    1131 }
    1132 
    1133 ContentSpecNode* SchemaValidator::getNonUnaryGroup(ContentSpecNode* const pNode) {
    1134 
    1135     int pNodeType = (pNode->getType() & 0x0f);
    1136     if (pNodeType == ContentSpecNode::Leaf
    1137         || pNodeType == ContentSpecNode::Any
    1138         || pNodeType == ContentSpecNode::Any_Other
    1139         || pNodeType == ContentSpecNode::Any_NS)
    1140         return pNode;
    1141 
    1142     if (pNode->getMinOccurs() == 1 && pNode->getMaxOccurs() == 1
    1143         && pNode->getFirst() && !pNode->getSecond())
    1144         return getNonUnaryGroup(pNode->getFirst());
    1145 
    1146     return pNode;
    1147 }
    1148 
    1149 void SchemaValidator::checkParticleDerivationOk(SchemaGrammar* const aGrammar,
    1150                                                 ContentSpecNode* const curNode,
    1151                                                 const int derivedScope,
    1152                                                 ContentSpecNode* const baseNode,
    1153                                                 const int baseScope,
    1154                                                 const ComplexTypeInfo* const baseInfo,
    1155                                                 const bool toCheckOccurence) {
    1156 
    1157     // Check for pointless occurrences of all, choice, sequence.  The result is
    1158     // the contentspec which is not pointless. If the result is a non-pointless
    1159     // group, Vector is filled  in with the children of interest
    1160     if (curNode && !baseNode)
    1161         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_EmptyBase, fMemoryManager);
    1162 
    1163     if (!curNode)
    1164         return;
    1165 
    1166     ContentSpecNode* curSpecNode = getNonUnaryGroup(curNode);
    1167     ContentSpecNode* baseSpecNode = getNonUnaryGroup(baseNode);
    1168     ValueVectorOf<ContentSpecNode*> curVector(8, fMemoryManager);
    1169     ValueVectorOf<ContentSpecNode*> baseVector(8, fMemoryManager);
    1170     ContentSpecNode::NodeTypes curNodeType = curSpecNode->getType();
    1171     ContentSpecNode::NodeTypes baseNodeType = baseSpecNode->getType();
    1172 
    1173     if ((curNodeType & 0x0f) == ContentSpecNode::Sequence ||
    1174         (curNodeType & 0x0f) == ContentSpecNode::Choice ||
    1175         curNodeType == ContentSpecNode::All) {
    1176         curSpecNode = checkForPointlessOccurrences(curSpecNode, curNodeType, &curVector);
    1177     }
    1178 
    1179     if ((baseNodeType & 0x0f) == ContentSpecNode::Sequence ||
    1180         (baseNodeType & 0x0f) == ContentSpecNode::Choice ||
    1181         baseNodeType == ContentSpecNode::All) {
    1182         baseSpecNode = checkForPointlessOccurrences(baseSpecNode, baseNodeType, &baseVector);
    1183     }
    1184 
    1185     curNodeType = curSpecNode->getType();
    1186     baseNodeType = baseSpecNode->getType();
    1187 
    1188     switch (curNodeType & 0x0f) {
    1189     case ContentSpecNode::Leaf:
    1190         {
    1191             switch (baseNodeType & 0x0f) {
    1192             case ContentSpecNode::Leaf:
    1193                 {
    1194                     checkNameAndTypeOK(aGrammar, curSpecNode, derivedScope, baseSpecNode, baseScope, baseInfo);
    1195                     return;
    1196                 }
    1197             case ContentSpecNode::Any:
    1198             case ContentSpecNode::Any_Other:
    1199             case ContentSpecNode::Any_NS:
    1200                 {
    1201                     checkNSCompat(curSpecNode, baseSpecNode, toCheckOccurence);
    1202                     return;
    1203                 }
    1204             case ContentSpecNode::Choice:
    1205             case ContentSpecNode::Sequence:
    1206             case ContentSpecNode::All:
    1207                 {
    1208                     checkRecurseAsIfGroup(aGrammar, curSpecNode, derivedScope,
    1209                                           baseSpecNode, baseScope, &baseVector, baseInfo);
    1210                     return;
    1211                 }
    1212             default:
    1213                 {
    1214                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_InvalidContentType, fMemoryManager);
    1215                 }
    1216             }
    1217         }
    1218     case ContentSpecNode::Any:
    1219     case ContentSpecNode::Any_Other:
    1220     case ContentSpecNode::Any_NS:
    1221         {
    1222             switch (baseNodeType & 0x0f) {
    1223             case ContentSpecNode::Any:
    1224             case ContentSpecNode::Any_Other:
    1225             case ContentSpecNode::Any_NS:
    1226                 {
    1227                      checkNSSubset(curSpecNode, baseSpecNode);
    1228                      return;
    1229                 }
    1230             case ContentSpecNode::Choice:
    1231             case ContentSpecNode::Sequence:
    1232             case ContentSpecNode::All:
    1233             case ContentSpecNode::Leaf:
    1234                 {
    1235                     if (baseNodeType == ContentSpecNode::Any_NS_Choice) {
    1236                         if (checkNSSubsetChoiceRoot(curSpecNode, baseSpecNode)) {
    1237                             return;
    1238                         }
    1239                     }
    1240 
    1241                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_ForbiddenRes1, fMemoryManager);
    1242                 }
    1243             default:
    1244                 {
    1245                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_InvalidContentType, fMemoryManager);
    1246                 }
    1247             }
    1248         }
    1249     case ContentSpecNode::All:
    1250         {
    1251             switch (baseNodeType & 0x0f) {
    1252             case ContentSpecNode::Any:
    1253             case ContentSpecNode::Any_Other:
    1254             case ContentSpecNode::Any_NS:
    1255                 {
    1256                     checkNSRecurseCheckCardinality(aGrammar, curSpecNode, &curVector, derivedScope, baseSpecNode, toCheckOccurence);
    1257                     return;
    1258                 }
    1259             case ContentSpecNode::All:
    1260                 {
    1261                     checkRecurse(aGrammar, curSpecNode, derivedScope, &curVector,
    1262                                  baseSpecNode, baseScope, &baseVector, baseInfo);
    1263                     return;
    1264                 }
    1265             case ContentSpecNode::Choice:
    1266             case ContentSpecNode::Sequence:
    1267             case ContentSpecNode::Leaf:
    1268                 {
    1269                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_ForbiddenRes2, fMemoryManager);
    1270                 }
    1271             default:
    1272                 {
    1273                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_InvalidContentType, fMemoryManager);
    1274                 }
    1275             }
    1276         }
    1277     case ContentSpecNode::Choice:
    1278         {
    1279             switch (baseNodeType & 0x0f) {
    1280             case ContentSpecNode::Any:
    1281             case ContentSpecNode::Any_Other:
    1282             case ContentSpecNode::Any_NS:
    1283                 {
    1284                     checkNSRecurseCheckCardinality(aGrammar, curSpecNode, &curVector, derivedScope, baseSpecNode, toCheckOccurence);
    1285                     return;
    1286                 }
    1287             case ContentSpecNode::Choice:
    1288                 {
    1289                     checkRecurse(aGrammar, curSpecNode, derivedScope, &curVector,
    1290                                  baseSpecNode, baseScope, &baseVector, baseInfo, true);
    1291                     return;
    1292                 }
    1293             case ContentSpecNode::All:
    1294             case ContentSpecNode::Sequence:
    1295             case ContentSpecNode::Leaf:
    1296                 {
    1297                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_ForbiddenRes3, fMemoryManager);
    1298                 }
    1299             default:
    1300                 {
    1301                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_InvalidContentType, fMemoryManager);
    1302                 }
    1303             }
    1304         }
    1305     case ContentSpecNode::Sequence:
    1306         {
    1307             switch (baseNodeType & 0x0f) {
    1308             case ContentSpecNode::Any:
    1309             case ContentSpecNode::Any_Other:
    1310             case ContentSpecNode::Any_NS:
    1311                 {
    1312                     checkNSRecurseCheckCardinality(aGrammar, curSpecNode, &curVector, derivedScope, baseSpecNode, toCheckOccurence);
    1313                     return;
    1314                 }
    1315             case ContentSpecNode::All:
    1316                 {
    1317                     checkRecurseUnordered(aGrammar, curSpecNode, &curVector, derivedScope,
    1318                                           baseSpecNode, &baseVector, baseScope, baseInfo);
    1319                     return;
    1320                 }
    1321             case ContentSpecNode::Sequence:
    1322                 {
    1323                     checkRecurse(aGrammar, curSpecNode, derivedScope, &curVector,
    1324                                  baseSpecNode, baseScope, &baseVector, baseInfo);
    1325                     return;
    1326                 }
    1327             case ContentSpecNode::Choice:
    1328                 {
    1329                     checkMapAndSum(aGrammar, curSpecNode, &curVector, derivedScope,
    1330                                    baseSpecNode, &baseVector, baseScope, baseInfo);
    1331                     return;
    1332                 }
    1333             case ContentSpecNode::Leaf:
    1334                 {
    1335                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_ForbiddenRes4, fMemoryManager);
    1336                 }
    1337             default:
    1338                 {
    1339                     ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_InvalidContentType, fMemoryManager);
    1340                 }
    1341             }
    1342         }
    1343     }
    1344 }
    1345 
    1346 ContentSpecNode*
    1347 SchemaValidator::checkForPointlessOccurrences(ContentSpecNode* const specNode,
    1348                                               const ContentSpecNode::NodeTypes nodeType,
    1349                                               ValueVectorOf<ContentSpecNode*>* const nodes) {
    1350 
    1351     ContentSpecNode* rightNode = specNode->getSecond();
    1352     int min = specNode->getMinOccurs();
    1353     int max = specNode->getMaxOccurs();
    1354 
    1355     if (!rightNode) {
    1356 
    1357          gatherChildren(nodeType, specNode->getFirst(), nodes);
    1358 
    1359          if (nodes->size() == 1 && min == 1 && max == 1) {
    1360             return nodes->elementAt(0);
    1361         }
    1362 
    1363         return specNode;
    1364     }
    1365 
    1366     gatherChildren(nodeType, specNode->getFirst(), nodes);
    1367     gatherChildren(nodeType, rightNode, nodes);
    1368 
    1369     return specNode;
    1370 }
    1371 
    1372 void SchemaValidator::gatherChildren(const ContentSpecNode::NodeTypes parentNodeType,
    1373                                     ContentSpecNode* const specNode,
    1374                                     ValueVectorOf<ContentSpecNode*>* const nodes) {
    1375 
    1376     if (!specNode) {
    1377         return;
    1378     }
    1379 
    1380     int min = specNode->getMinOccurs();
    1381     int max = specNode->getMaxOccurs();
    1382     ContentSpecNode::NodeTypes nodeType = specNode->getType();
    1383     ContentSpecNode* rightNode = specNode->getSecond();
    1384 
    1385     if (nodeType == ContentSpecNode::Leaf ||
    1386         (nodeType & 0x0f) == ContentSpecNode::Any ||
    1387         (nodeType & 0x0f) == ContentSpecNode::Any_NS ||
    1388         (nodeType & 0x0f) == ContentSpecNode::Any_Other) {
    1389         nodes->addElement(specNode);
    1390     }
    1391     else if (min !=1 || max != 1) {
    1392         nodes->addElement(specNode);
    1393     }
    1394     else if (!rightNode) {
    1395         gatherChildren(nodeType, specNode->getFirst(), nodes);
    1396     }
    1397     else if ((parentNodeType & 0x0f) == (nodeType & 0x0f)) {
    1398 
    1399         gatherChildren(nodeType, specNode->getFirst(), nodes);
    1400         gatherChildren(nodeType, rightNode, nodes);
    1401     }
    1402     else {
    1403         nodes->addElement(specNode);
    1404     }
    1405 }
    1406 
    1407 void
    1408 SchemaValidator::checkNSCompat(const ContentSpecNode* const derivedSpecNode,
    1409                                const ContentSpecNode* const baseSpecNode,
    1410                                const bool toCheckOccurence) {
    1411 
    1412     // check Occurrence ranges
    1413     if (toCheckOccurence &&
    1414         !isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
    1415                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
    1416         ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_OccurRangeE,
    1417                   derivedSpecNode->getElement()->getLocalPart(), fMemoryManager);
    1418     }
    1419 
    1420     // check wildcard subset
    1421     if (!wildcardEltAllowsNamespace(baseSpecNode, derivedSpecNode->getElement()->getURI())) {
    1422         ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_NSCompat1,
    1423                   derivedSpecNode->getElement()->getLocalPart(), fMemoryManager);
    1424     }
    1425 }
    1426 
    1427 bool
    1428 SchemaValidator::wildcardEltAllowsNamespace(const ContentSpecNode* const baseSpecNode,
    1429                                             const unsigned int derivedURI) {
    1430 
    1431     ContentSpecNode::NodeTypes nodeType = baseSpecNode->getType();
    1432 
    1433     if ((nodeType & 0x0f) == ContentSpecNode::Any) {
    1434         return true;
    1435     }
    1436 
    1437     unsigned int baseURI = baseSpecNode->getElement()->getURI();
    1438 
    1439     if ((nodeType & 0x0f) == ContentSpecNode::Any_NS) {
    1440         if (derivedURI == baseURI) {
    1441            return true;
    1442         }
    1443     }
    1444     else { // must be ANY_OTHER
    1445         if (derivedURI != baseURI && derivedURI != getScanner()->getEmptyNamespaceId()) {
    1446             return true;
    1447         }
    1448     }
    1449 
    1450     return false;
    1451 }
    1452 
    1453 void
    1454 SchemaValidator::checkNameAndTypeOK(SchemaGrammar* const currentGrammar,
    1455                                     const ContentSpecNode* const derivedSpecNode,
    1456                                     const int derivedScope,
    1457                                     const ContentSpecNode* const baseSpecNode,
    1458                                     const int baseScope,
    1459                                     const ComplexTypeInfo* const baseInfo) {
    1460 
    1461     if (derivedSpecNode->getMaxOccurs() == 0)
    1462         return;
    1463 
    1464     unsigned int derivedURI = derivedSpecNode->getElement()->getURI();
    1465 
    1466     // case of mixed complex types with attributes only
    1467     if (derivedURI == XMLElementDecl::fgPCDataElemId) {
    1468         return;
    1469     }
    1470 
    1471     SchemaGrammar* dGrammar = currentGrammar;
    1472 
    1473     if (derivedURI != getScanner()->getEmptyNamespaceId())
    1474     {
    1475         const XMLCh* dURI = fGrammarResolver->getStringPool()->getValueForId(derivedURI);
    1476         dGrammar= (SchemaGrammar*) fGrammarResolver->getGrammar(dURI);
    1477     }
    1478 
    1479     if (!dGrammar) { //something is wrong
    1480         return;
    1481     }
    1482 
    1483     const XMLCh* derivedName = derivedSpecNode->getElement()->getLocalPart();
    1484 
    1485     SchemaElementDecl* derivedElemDecl = findElement(derivedScope, derivedURI, derivedName, dGrammar);
    1486 
    1487     if (!derivedElemDecl) {
    1488         return;
    1489     }
    1490 
    1491     const XMLCh* baseName = baseSpecNode->getElement()->getLocalPart();
    1492     unsigned int baseURI = baseSpecNode->getElement()->getURI();
    1493     bool subsGroup = false;
    1494 
    1495     if (!XMLString::equals(derivedName, baseName) || derivedURI != baseURI) {
    1496         // Check if derived is substitutable for base.
    1497         //
    1498         SchemaElementDecl* e = derivedElemDecl->getSubstitutionGroupElem ();
    1499 
    1500         for (; e != 0; e = e->getSubstitutionGroupElem ()) {
    1501             if (XMLString::equals(e->getBaseName (), baseName) && e->getURI () == baseURI) {
    1502                 break;
    1503             }
    1504         }
    1505 
    1506         if (e == 0) {
    1507             ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_NameTypeOK1, fMemoryManager);
    1508         }
    1509 
    1510         subsGroup = true;
    1511     }
    1512 
    1513     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
    1514                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
    1515         ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_OccurRangeE, derivedName, fMemoryManager);
    1516     }
    1517 
    1518     // Find the schema grammar for the base element using the base type as
    1519     // a reference if it is available (it is unavailable if we are checking
    1520     // element group restriction which happens in redefine).
    1521     //
    1522     SchemaGrammar* bGrammar = dGrammar;
    1523 
    1524     if (baseInfo)
    1525     {
    1526         const XMLCh* baseTypeURI = baseInfo->getTypeUri ();
    1527 
    1528         if (baseTypeURI != 0 && *baseTypeURI != 0) // Non-empty namespace.
    1529             bGrammar= (SchemaGrammar*) fGrammarResolver->getGrammar(baseTypeURI);
    1530 
    1531         if (!bGrammar) { //something is wrong
    1532             return;
    1533         }
    1534     }
    1535 
    1536     SchemaElementDecl* baseElemDecl =
    1537         findElement(baseScope, baseURI, baseName, bGrammar, baseInfo);
    1538 
    1539     if (!baseElemDecl) {
    1540         return;
    1541     }
    1542 
    1543     int derivedFlags = derivedElemDecl->getMiscFlags();
    1544     int baseFlags = baseElemDecl->getMiscFlags();
    1545 
    1546     if (((baseFlags & SchemaSymbols::XSD_NILLABLE) == 0) &&
    1547                 ((derivedFlags & SchemaSymbols::XSD_NILLABLE) != 0)) {
    1548         ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_NameTypeOK2, derivedName, fMemoryManager);
    1549     }
    1550 
    1551     const XMLCh* derivedDefVal = derivedElemDecl->getDefaultValue();
    1552     const XMLCh* baseDefVal = baseElemDecl->getDefaultValue();
    1553 
    1554     if (baseDefVal && (baseFlags & SchemaSymbols::XSD_FIXED) != 0 &&
    1555         ((derivedFlags & SchemaSymbols::XSD_FIXED) == 0 ||
    1556          !XMLString::equals(derivedDefVal, baseDefVal))) {
    1557         ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_NameTypeOK3, derivedName, fMemoryManager);
    1558     }
    1559 
    1560     int derivedBlockSet = derivedElemDecl->getBlockSet();
    1561     int baseBlockSet = baseElemDecl->getBlockSet();
    1562 
    1563     if ((derivedBlockSet & baseBlockSet) != baseBlockSet) {
    1564         ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_NameTypeOK4, derivedName, fMemoryManager);
    1565     }
    1566 
    1567     // check identity constraints
    1568     checkICRestriction(derivedElemDecl, baseElemDecl, derivedName, baseName);
    1569 
    1570     // check that the derived element's type is derived from the base's.
    1571     if (!subsGroup)
    1572         checkTypesOK(derivedElemDecl, baseElemDecl, derivedName);
    1573 }
    1574 
    1575 SchemaElementDecl*
    1576 SchemaValidator::findElement(const int scope, const unsigned int uriIndex,
    1577                              const XMLCh* const name,
    1578                              SchemaGrammar* const grammar,
    1579                              const ComplexTypeInfo* const typeInfo) {
    1580 
    1581     // check for element at given scope first
    1582     SchemaElementDecl* elemDecl = (SchemaElementDecl*) grammar->getElemDecl(uriIndex, name, 0, scope);
    1583 
    1584     // if not found, check at global scope
    1585     if (!elemDecl) {
    1586 
    1587         elemDecl = (SchemaElementDecl*)
    1588             grammar->getElemDecl(uriIndex, name, 0, Grammar::TOP_LEVEL_SCOPE);
    1589 
    1590         // if still not found, and base is specified, look it up there
    1591         if (!elemDecl && typeInfo) {
    1592 
    1593             const ComplexTypeInfo* baseInfo = typeInfo;
    1594 
    1595             while (baseInfo) {
    1596 
    1597                 elemDecl = (SchemaElementDecl*)
    1598                     grammar->getElemDecl(uriIndex, name, 0, baseInfo->getScopeDefined());
    1599 
    1600                 if (elemDecl) {
    1601                    break;
    1602                 }
    1603 
    1604                 baseInfo = baseInfo->getBaseComplexTypeInfo();
    1605             }
    1606         }
    1607     }
    1608 
    1609     return elemDecl;
    1610 }
    1611 
    1612 void
    1613 SchemaValidator::checkICRestriction(const SchemaElementDecl* const derivedElemDecl,
    1614                                    const SchemaElementDecl* const baseElemDecl,
    1615                                    const XMLCh* const derivedElemName,
    1616                                    const XMLCh* const baseElemName) {
    1617 
    1618     // REVIST - need to get more clarification
    1619     XMLSize_t derivedICCount = derivedElemDecl->getIdentityConstraintCount();
    1620     XMLSize_t baseICCount = baseElemDecl->getIdentityConstraintCount();
    1621 
    1622     if (derivedICCount > baseICCount) {
    1623         ThrowXMLwithMemMgr2(RuntimeException, XMLExcepts::PD_NameTypeOK6, derivedElemName, baseElemName, fMemoryManager);
    1624     }
    1625 
    1626     for (XMLSize_t i=0; i < derivedICCount; i++) {
    1627 
    1628         bool found = false;
    1629         IdentityConstraint* ic= derivedElemDecl->getIdentityConstraintAt(i);
    1630 
    1631         for (XMLSize_t j=0; j < baseICCount; j++) {
    1632             if (*ic == *(baseElemDecl->getIdentityConstraintAt(j))) {
    1633 
    1634                 found = true;
    1635                 break;
    1636             }
    1637         }
    1638 
    1639         if (!found) {
    1640             ThrowXMLwithMemMgr2(RuntimeException, XMLExcepts::PD_NameTypeOK7, derivedElemName, baseElemName, fMemoryManager);
    1641         }
    1642     }
    1643 }
    1644 
    1645 void
    1646 SchemaValidator::checkTypesOK(const SchemaElementDecl* const derivedElemDecl,
    1647                               const SchemaElementDecl* const baseElemDecl,
    1648                               const XMLCh* const derivedElemName) {
    1649 
    1650     SchemaElementDecl::ModelTypes baseType = baseElemDecl->getModelType();
    1651 
    1652     if (baseType == SchemaElementDecl::Any) {
    1653         return;
    1654     }
    1655 
    1656     ComplexTypeInfo* rInfo = derivedElemDecl->getComplexTypeInfo();
    1657     ComplexTypeInfo* bInfo = baseElemDecl->getComplexTypeInfo();
    1658 
    1659     if (derivedElemDecl->getModelType() == SchemaElementDecl::Simple) {
    1660 
    1661         if (baseType != SchemaElementDecl::Simple) {
    1662             ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_NameTypeOK5, derivedElemName, fMemoryManager);
    1663         }
    1664 
    1665         if (!rInfo) {
    1666 
    1667             DatatypeValidator* bDV = baseElemDecl->getDatatypeValidator();
    1668 
    1669             if (bInfo || bDV == 0 ||
    1670                                 !bDV->isSubstitutableBy(derivedElemDecl->getDatatypeValidator())) {
    1671                 ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_NameTypeOK5, derivedElemName, fMemoryManager);
    1672             }
    1673 
    1674             return;
    1675         }
    1676     }
    1677 
    1678     if (rInfo == bInfo)
    1679         return;
    1680 
    1681     for (; rInfo && rInfo != bInfo; rInfo = rInfo->getBaseComplexTypeInfo()) {
    1682         if (rInfo->getDerivedBy() != SchemaSymbols::XSD_RESTRICTION) {
    1683 
    1684             rInfo = 0;
    1685             break;
    1686         }
    1687     }
    1688 
    1689     if (!rInfo) {
    1690         ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::PD_NameTypeOK5, derivedElemName, fMemoryManager);
    1691     }
    1692 }
    1693 
    1694 void
    1695 SchemaValidator::checkRecurseAsIfGroup(SchemaGrammar* const currentGrammar,
    1696                                        ContentSpecNode* const derivedSpecNodeIn,
    1697                                        const int derivedScope,
    1698                                        const ContentSpecNode* const baseSpecNode,
    1699                                        const int baseScope,
    1700                                        ValueVectorOf<ContentSpecNode*>* const baseNodes,
    1701                                        const ComplexTypeInfo* const baseInfo) {
    1702 
    1703     ContentSpecNode::NodeTypes baseType = baseSpecNode->getType();
    1704     bool toLax = false;
    1705 
    1706     //Treat the element as if it were in a group of the same variety as base
    1707     ContentSpecNode derivedGroupNode(baseType, derivedSpecNodeIn, 0, false, true, fMemoryManager);
    1708     const ContentSpecNode* const derivedSpecNode = &derivedGroupNode;
    1709 
    1710     if ((baseSpecNode->getType() & 0x0f) == ContentSpecNode::Choice) {
    1711         toLax = true;
    1712     }
    1713 
    1714     // Instead of calling this routine, inline it
    1715     // checkRecurse(currentGrammar, &derivedGroupNode, derivedScope, &derivedNodes,
    1716     //             baseSpecNode, baseScope, baseNodes, baseInfo, toLax);
    1717 
    1718     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
    1719                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
    1720         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_Recurse1, fMemoryManager);
    1721     }
    1722 
    1723     // check for mapping of children
    1724     XMLExcepts::Codes codeToThrow = XMLExcepts::NoError;
    1725     XMLSize_t count2= baseNodes->size();
    1726     XMLSize_t current = 0;
    1727 
    1728     {
    1729         bool matched = false;
    1730 
    1731         for (XMLSize_t j = current; j < count2; j++) {
    1732 
    1733             ContentSpecNode* baseNode = baseNodes->elementAt(j);
    1734             current++;
    1735 
    1736             bool bDoBreak=false;    // workaround for Borland bug with 'break' in 'catch'
    1737             try {
    1738 
    1739                 checkParticleDerivationOk(currentGrammar, derivedSpecNodeIn,
    1740                                           derivedScope, baseNode, baseScope, baseInfo);
    1741                 matched = true;
    1742                 break;
    1743             }
    1744             catch(const XMLException&) {
    1745                 if (!toLax && baseNode->getMinTotalRange()) {
    1746                     bDoBreak=true;
    1747                 }
    1748             }
    1749             if(bDoBreak)
    1750                 break;
    1751         }
    1752 
    1753         // did not find a match
    1754         if (!matched) {
    1755             codeToThrow = XMLExcepts::PD_Recurse2;
    1756         }
    1757     }
    1758 
    1759     // Now, see if there are some elements in the base we didn't match up
    1760     // in case of Sequence or All
    1761     if (!toLax && codeToThrow == XMLExcepts::NoError) {
    1762         for (XMLSize_t j = current; j < count2; j++) {
    1763             if (baseNodes->elementAt(j)->getMinTotalRange() * baseSpecNode->getMinOccurs()) { //!emptiable
    1764                 codeToThrow =  XMLExcepts::PD_Recurse2;
    1765                 break;
    1766             }
    1767         }
    1768     }
    1769 
    1770     if (codeToThrow != XMLExcepts::NoError) {
    1771         ThrowXMLwithMemMgr(RuntimeException, codeToThrow, fMemoryManager);
    1772     }
    1773 }
    1774 
    1775 void
    1776 SchemaValidator::checkRecurse(SchemaGrammar* const currentGrammar,
    1777                               const ContentSpecNode* const derivedSpecNode,
    1778                               const int derivedScope,
    1779                               ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    1780                               const ContentSpecNode* const baseSpecNode,
    1781                               const int baseScope,
    1782                               ValueVectorOf<ContentSpecNode*>* const baseNodes,
    1783                               const ComplexTypeInfo* const baseInfo,
    1784                               const bool toLax) {
    1785 
    1786     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
    1787                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
    1788         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_Recurse1, fMemoryManager);
    1789     }
    1790 
    1791     // check for mapping of children
    1792     XMLExcepts::Codes codeToThrow = XMLExcepts::NoError;
    1793     XMLSize_t count1= derivedNodes->size();
    1794     XMLSize_t count2= baseNodes->size();
    1795     XMLSize_t current = 0;
    1796 
    1797     for (XMLSize_t i=0; i<count1; i++) {
    1798 
    1799         bool matched = false;
    1800 
    1801         for (XMLSize_t j = current; j < count2; j++) {
    1802 
    1803             ContentSpecNode* baseNode = baseNodes->elementAt(j);
    1804             current++;
    1805 
    1806             bool bDoBreak=false;    // workaround for Borland bug with 'break' in 'catch'
    1807             try {
    1808 
    1809                 checkParticleDerivationOk(currentGrammar, derivedNodes->elementAt(i),
    1810                                           derivedScope, baseNode, baseScope, baseInfo);
    1811                 matched = true;
    1812                 break;
    1813             }
    1814             catch(const XMLException&) {
    1815                 if (!toLax && baseNode->getMinTotalRange()) {
    1816                     bDoBreak=true;
    1817                 }
    1818             }
    1819             if(bDoBreak)
    1820                 break;
    1821         }
    1822 
    1823         // did not find a match
    1824         if (!matched) {
    1825 
    1826             codeToThrow = XMLExcepts::PD_Recurse2;
    1827             break;
    1828         }
    1829     }
    1830 
    1831     // Now, see if there are some elements in the base we didn't match up
    1832     // in case of Sequence or All
    1833     if (!toLax && codeToThrow == XMLExcepts::NoError) {
    1834         for (XMLSize_t j = current; j < count2; j++) {
    1835             if (baseNodes->elementAt(j)->getMinTotalRange()) { //!emptiable
    1836                 codeToThrow =  XMLExcepts::PD_Recurse2;
    1837                 break;
    1838             }
    1839         }
    1840     }
    1841 
    1842     if (codeToThrow != XMLExcepts::NoError) {
    1843         ThrowXMLwithMemMgr(RuntimeException, codeToThrow, fMemoryManager);
    1844     }
    1845 }
    1846 
    1847 void SchemaValidator::checkNSSubset(const ContentSpecNode* const derivedSpecNode,
    1848                                     const ContentSpecNode* const baseSpecNode) {
    1849 
    1850     // check Occurrence ranges
    1851     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
    1852                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
    1853         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_NSSubset1, fMemoryManager);
    1854     }
    1855 
    1856     if (!isWildCardEltSubset(derivedSpecNode, baseSpecNode)) {
    1857         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_NSSubset2, fMemoryManager);
    1858     }
    1859 }
    1860 
    1861 bool SchemaValidator::checkNSSubsetChoiceRoot(const ContentSpecNode* const derivedSpecNode,
    1862                                     const ContentSpecNode* const baseSpecNode) {
    1863     bool found = false;
    1864 
    1865     if (baseSpecNode->getType() == ContentSpecNode::Any_NS_Choice) {
    1866         const ContentSpecNode* first = baseSpecNode->getFirst();
    1867         const ContentSpecNode* second = baseSpecNode->getSecond();
    1868 
    1869         if (first) {
    1870             found = checkNSSubsetChoiceRoot(derivedSpecNode, first);
    1871             if (found) return true;
    1872         }
    1873         if (second) {
    1874             found = checkNSSubsetChoiceRoot(derivedSpecNode, second);
    1875             if (found) return true;
    1876         }
    1877     }
    1878     else { // should be Any_NS
    1879         found = checkNSSubsetChoice(derivedSpecNode, baseSpecNode);
    1880     }
    1881 
    1882     return found;
    1883 }
    1884 
    1885 bool SchemaValidator::checkNSSubsetChoice(const ContentSpecNode* const derivedSpecNode,
    1886                                     const ContentSpecNode* const baseSpecNode) {
    1887 
    1888     // check Occurrence ranges
    1889     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
    1890                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
    1891         return false;
    1892     }
    1893 
    1894     if (!isWildCardEltSubset(derivedSpecNode, baseSpecNode)) {
    1895         return false;
    1896     }
    1897     return true;
    1898 }
    1899 
    1900 bool
    1901 SchemaValidator::isWildCardEltSubset(const ContentSpecNode* const derivedSpecNode,
    1902                                      const ContentSpecNode* const baseSpecNode) {
    1903 
    1904     ContentSpecNode::NodeTypes baseType = baseSpecNode->getType();
    1905 
    1906     if ((baseType & 0x0f) == ContentSpecNode::Any) {
    1907         return true;
    1908     }
    1909 
    1910     ContentSpecNode::NodeTypes derivedType = derivedSpecNode->getType();
    1911     unsigned int baseURI = baseSpecNode->getElement()->getURI();
    1912     unsigned int derivedURI = derivedSpecNode->getElement()->getURI();
    1913 
    1914     // Below we assume that empty string has id 1.
    1915     //
    1916     if (((derivedType & 0x0f) == ContentSpecNode::Any_Other) &&
    1917         ((baseType & 0x0f) == ContentSpecNode::Any_Other) &&
    1918         (baseURI == derivedURI || baseURI == 1)) {
    1919         return true;
    1920     }
    1921 
    1922     if ((derivedType & 0x0f) == ContentSpecNode::Any_NS) {
    1923 
    1924         if (((baseType & 0x0f) == ContentSpecNode::Any_NS) &&
    1925             baseURI == derivedURI) {
    1926             return true;
    1927         }
    1928 
    1929         if (((baseType & 0x0f) == ContentSpecNode::Any_Other) &&
    1930             (derivedURI == 1 || baseURI != derivedURI)) {
    1931             return true;
    1932         }
    1933     }
    1934 
    1935     return false;
    1936 }
    1937 
    1938 void
    1939 SchemaValidator::checkNSRecurseCheckCardinality(SchemaGrammar* const currentGrammar,
    1940                                                 const ContentSpecNode* const derivedSpecNode,
    1941                                                 ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    1942                                                 const int derivedScope,
    1943                                                 ContentSpecNode* const baseSpecNode,
    1944                                                 const bool toCheckOccurence) {
    1945 
    1946     // Implement total range check
    1947     int derivedMin = derivedSpecNode->getMinTotalRange();
    1948     int derivedMax = derivedSpecNode->getMaxTotalRange();
    1949 
    1950     // check Occurrence ranges
    1951     if (toCheckOccurence &&
    1952         !isOccurrenceRangeOK(derivedMin, derivedMax, baseSpecNode->getMinOccurs(),
    1953                               baseSpecNode->getMaxOccurs())) {
    1954         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_NSRecurseCheckCardinality1, fMemoryManager);
    1955     }
    1956 
    1957     // Check that each member of the group is a valid restriction of the wildcard
    1958     XMLSize_t nodesCount = derivedNodes->size();
    1959 
    1960     for (XMLSize_t i = 0; i < nodesCount; i++) {
    1961         checkParticleDerivationOk(currentGrammar, derivedNodes->elementAt(i), derivedScope, baseSpecNode, -1, 0, false);
    1962     }
    1963 }
    1964 
    1965 void
    1966 SchemaValidator::checkRecurseUnordered(SchemaGrammar* const currentGrammar,
    1967                                        const ContentSpecNode* const derivedSpecNode,
    1968                                        ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    1969                                        const int derivedScope,
    1970                                        ContentSpecNode* const baseSpecNode,
    1971                                        ValueVectorOf<ContentSpecNode*>* const baseNodes,
    1972                                        const int baseScope,
    1973                                        const ComplexTypeInfo* const baseInfo) {
    1974 
    1975     // check Occurrence ranges
    1976     if (!isOccurrenceRangeOK(derivedSpecNode->getMinOccurs(), derivedSpecNode->getMaxOccurs(),
    1977                              baseSpecNode->getMinOccurs(), baseSpecNode->getMaxOccurs())) {
    1978         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_Recurse1, fMemoryManager);
    1979     }
    1980 
    1981     XMLExcepts::Codes  codeToThrow = XMLExcepts::NoError;
    1982     XMLSize_t          derivedCount= derivedNodes->size();
    1983     XMLSize_t          baseCount = baseNodes->size();
    1984     bool*              foundIt = (bool*) fMemoryManager->allocate
    1985     (
    1986         baseCount * sizeof(bool)
    1987     );//new bool[baseCount];
    1988     ArrayJanitor<bool> janFoundIt(foundIt, fMemoryManager);
    1989 
    1990     for (XMLSize_t k=0; k < baseCount; k++) {
    1991         foundIt[k] = false;
    1992     }
    1993 
    1994     // check for mapping of children
    1995     for (XMLSize_t i = 0; i < derivedCount; i++) {
    1996 
    1997         ContentSpecNode* derivedNode = derivedNodes->elementAt(i);
    1998         bool matched = false;
    1999 
    2000         for (XMLSize_t j = 0; j < baseCount; j++) {
    2001 
    2002             try {
    2003 
    2004                 checkParticleDerivationOk(currentGrammar, derivedNode, derivedScope,
    2005                                           baseNodes->elementAt(j), baseScope, baseInfo);
    2006 
    2007                 if (foundIt[j]) {
    2008                     break;
    2009                 }
    2010 
    2011                 foundIt[j] = true;
    2012                 matched = true;
    2013                 break;
    2014             }
    2015             catch (const XMLException&) {
    2016             }
    2017         }
    2018 
    2019         // didn't find a match.
    2020         if (!matched) {
    2021 
    2022                 codeToThrow = XMLExcepts::PD_RecurseUnordered;
    2023             break;
    2024         }
    2025     }
    2026 
    2027     // For all unmapped particles in base, check to see it it's emptiable or not
    2028     if (codeToThrow == XMLExcepts::NoError) {
    2029         for (XMLSize_t j=0; j < baseCount; j++) {
    2030             if (!foundIt[j] && baseNodes->elementAt(j)->getMinTotalRange()) {
    2031 
    2032                     codeToThrow = XMLExcepts::PD_RecurseUnordered;
    2033                 break;
    2034             }
    2035         }
    2036     }
    2037 
    2038     if (codeToThrow != XMLExcepts::NoError) {
    2039         ThrowXMLwithMemMgr(RuntimeException, codeToThrow, fMemoryManager);
    2040     }
    2041 }
    2042 
    2043 void
    2044 SchemaValidator::checkMapAndSum(SchemaGrammar* const currentGrammar,
    2045                                 const ContentSpecNode* const derivedSpecNode,
    2046                                 ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    2047                                 const int derivedScope,
    2048                                 ContentSpecNode* const baseSpecNode,
    2049                                 ValueVectorOf<ContentSpecNode*>* const baseNodes,
    2050                                 const int baseScope,
    2051                                 const ComplexTypeInfo* const baseInfo) {
    2052 
    2053     // check Occurrence ranges
    2054     XMLSize_t derivedCount = derivedNodes->size();
    2055     XMLSize_t baseCount = baseNodes->size();
    2056     int derivedMin = derivedSpecNode->getMinOccurs() * (unsigned int)derivedCount;
    2057     int derivedMax = derivedSpecNode->getMaxOccurs();
    2058 
    2059     if (derivedMax != SchemaSymbols::XSD_UNBOUNDED) {
    2060         derivedMax *= (unsigned int)derivedCount;
    2061     }
    2062 
    2063     if (!isOccurrenceRangeOK(derivedMin, derivedMax, baseSpecNode->getMinOccurs(),
    2064                              baseSpecNode->getMaxOccurs())) {
    2065         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_Recurse1, fMemoryManager);
    2066     }
    2067 
    2068     // check for mapping of children
    2069     for (XMLSize_t i = 0; i < derivedCount; i++) {
    2070 
    2071         ContentSpecNode* derivedNode = derivedNodes->elementAt(i);
    2072         bool matched = false;
    2073 
    2074         for (XMLSize_t j = 0; j < baseCount && !matched; j++) {
    2075 
    2076             try {
    2077 
    2078                 checkParticleDerivationOk(currentGrammar, derivedNode, derivedScope,
    2079                                           baseNodes->elementAt(j), baseScope, baseInfo);
    2080                 matched = true;
    2081             }
    2082             catch (const XMLException&) {
    2083             }
    2084         }
    2085 
    2086         // didn't find a match.
    2087         if (!matched) {
    2088                 ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::PD_MapAndSum, fMemoryManager);
    2089         }
    2090     }
    2091 
    2092 }
    2093 
    2094 XERCES_CPP_NAMESPACE_END
     1#include <icxercesc/validators/schema/SchemaValidator.cpp>
  • icXML/icXML-devel/src/xercesc/validators/schema/SchemaValidator.hpp

    r2722 r2747  
    1 /*
    2  * Licensed to the Apache Software Foundation (ASF) under one or more
    3  * contributor license agreements.  See the NOTICE file distributed with
    4  * this work for additional information regarding copyright ownership.
    5  * The ASF licenses this file to You under the Apache License, Version 2.0
    6  * (the "License"); you may not use this file except in compliance with
    7  * the License.  You may obtain a copy of the License at
    8  *
    9  *      http://www.apache.org/licenses/LICENSE-2.0
    10  *
    11  * Unless required by applicable law or agreed to in writing, software
    12  * distributed under the License is distributed on an "AS IS" BASIS,
    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  * See the License for the specific language governing permissions and
    15  * limitations under the License.
    16  */
    17 
    18 /*
    19  * $Id: SchemaValidator.hpp 932887 2010-04-11 13:04:59Z borisk $
    20  */
    21 
    22 #if !defined(XERCESC_INCLUDE_GUARD_SCHEMAVALIDATOR_HPP)
    23 #define XERCESC_INCLUDE_GUARD_SCHEMAVALIDATOR_HPP
    24 
    25 #include <icxercesc/framework/XMLValidator.hpp>
    26 #include <icxercesc/framework/XMLBuffer.hpp>
    27 #include <xercesc/util/ValueStackOf.hpp>
    28 #include <xercesc/validators/common/ContentSpecNode.hpp>
    29 #include <xercesc/validators/schema/SchemaGrammar.hpp>
    30 #include <xercesc/validators/schema/XSDErrorReporter.hpp>
    31 
    32 XERCES_CPP_NAMESPACE_BEGIN
    33 
    34 class GrammarResolver;
    35 class DatatypeValidator;
    36 class SchemaElementDecl;
    37 
    38 //
    39 //  This is a derivative of the abstract validator interface. This class
    40 //  implements a validator that supports standard XML Schema semantics.
    41 //  This class handles scanning the of the schema, and provides
    42 //  the standard validation services against the Schema info it found.
    43 //
    44 class VALIDATORS_EXPORT SchemaValidator : public XMLValidator
    45 {
    46 public:
    47     // -----------------------------------------------------------------------
    48     //  Constructors and Destructor
    49     // -----------------------------------------------------------------------
    50     SchemaValidator
    51     (
    52           XMLErrorReporter* const errReporter = 0
    53           , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
    54     );
    55     virtual ~SchemaValidator();
    56 
    57     // -----------------------------------------------------------------------
    58     //  Implementation of the XMLValidator interface
    59     // -----------------------------------------------------------------------
    60     virtual bool checkContent
    61     (
    62         XMLElementDecl* const   elemDecl
    63         , QName** const         children
    64         , XMLSize_t             childCount
    65         , XMLSize_t*            indexFailingChild
    66     );
    67 
    68     virtual void faultInAttr
    69     (
    70                 XMLAttr&    toFill
    71         , const XMLAttDef&  attDef
    72     )   const;
    73 
    74     virtual void preContentValidation(bool reuseGrammar,
    75                                       bool validateDefAttr = false);
    76 
    77     virtual void postParseValidation();
    78 
    79     virtual void reset();
    80 
    81     virtual bool requiresNamespaces() const;
    82 
    83     virtual void validateAttrValue
    84     (
    85         const   XMLAttDef*                  attDef
    86         , const XMLCh* const                attrValue
    87         , bool                              preValidation = false
    88         , const XMLElementDecl*             elemDecl = 0
    89     );
    90 
    91     virtual void validateElement
    92     (
    93         const   XMLElementDecl*             elemDef
    94     );
    95 
    96     virtual Grammar* getGrammar() const;
    97     virtual void setGrammar(Grammar* aGrammar);
    98 
    99     // -----------------------------------------------------------------------
    100     //  Virtual DTD handler interface.
    101     // -----------------------------------------------------------------------
    102     virtual bool handlesDTD() const;
    103 
    104     // -----------------------------------------------------------------------
    105     //  Virtual Schema handler interface. handlesSchema() always return false.
    106     // -----------------------------------------------------------------------
    107     virtual bool handlesSchema() const;
    108 
    109     // -----------------------------------------------------------------------
    110     //  Schema Validator methods
    111     // -----------------------------------------------------------------------
    112     void normalizeWhiteSpace(DatatypeValidator* dV, const XMLCh* const value, XMLBuffer& toFill, bool bStandalone = false);
    113 
    114     // -----------------------------------------------------------------------
    115     //  Setter methods
    116     // -----------------------------------------------------------------------
    117     void setGrammarResolver(GrammarResolver* grammarResolver);
    118 
    119     void setXsiType(const XMLCh* const        prefix
    120       , const XMLCh* const        localPart
    121        , const unsigned int        uriId);
    122 
    123     void setNillable(bool isNil);
    124     void resetNillable();
    125     void setErrorReporter(XMLErrorReporter* const errorReporter);
    126     void setExitOnFirstFatal(const bool newValue);
    127     void setDatatypeBuffer(const XMLCh* const value);
    128     void clearDatatypeBuffer();
    129 
    130     // -----------------------------------------------------------------------
    131     //  Getter methods
    132     // -----------------------------------------------------------------------
    133     ComplexTypeInfo* getCurrentTypeInfo() const;
    134     DatatypeValidator *getCurrentDatatypeValidator() const;
    135     DatatypeValidator *getMostRecentAttrValidator() const;
    136     bool getErrorOccurred() const;
    137     bool getIsElemSpecified() const;
    138     bool getIsXsiTypeSet() const;
    139     const XMLCh* getNormalizedValue() const;
    140 
    141 private:
    142     // -----------------------------------------------------------------------
    143     //  Unimplemented constructors and operators
    144     // -----------------------------------------------------------------------
    145     SchemaValidator(const SchemaValidator&);
    146     SchemaValidator& operator=(const SchemaValidator&);
    147 
    148     // -----------------------------------------------------------------------
    149     //  Element Consistency Checking methods
    150     // -----------------------------------------------------------------------
    151     void checkRefElementConsistency(SchemaGrammar* const currentGrammar,
    152                                     const ComplexTypeInfo* const curTypeInfo,
    153                                     const XercesGroupInfo* const curGroup = 0);
    154 
    155     // -----------------------------------------------------------------------
    156     //  Particle Derivation Checking methods
    157     // -----------------------------------------------------------------------
    158     void checkParticleDerivation(SchemaGrammar* const currentGrammar,
    159                                  const ComplexTypeInfo* const typeInfo);
    160     void checkParticleDerivationOk(SchemaGrammar* const currentGrammar,
    161                                    ContentSpecNode* const curNode,
    162                                    const int derivedScope,
    163                                    ContentSpecNode* const baseNode,
    164                                    const int baseScope,
    165                                    const ComplexTypeInfo* const baseInfo = 0,
    166                                    const bool toCheckOccurrence = true);
    167     ContentSpecNode* checkForPointlessOccurrences(ContentSpecNode* const specNode,
    168                                                   const ContentSpecNode::NodeTypes nodeType,
    169                                                   ValueVectorOf<ContentSpecNode*>* const nodes);
    170     void gatherChildren(const ContentSpecNode::NodeTypes parentNodeType,
    171                         ContentSpecNode* const specNode,
    172                         ValueVectorOf<ContentSpecNode*>* const nodes);
    173     bool isOccurrenceRangeOK(const int min1, const int max1, const int min2, const int max2);
    174     void checkNSCompat(const ContentSpecNode* const derivedSpecNode,
    175                        const ContentSpecNode* const baseSpecNode,
    176                        const bool toCheckOccurence);
    177     bool wildcardEltAllowsNamespace(const ContentSpecNode* const baseSpecNode,
    178                                     const unsigned int derivedURI);
    179     void checkNameAndTypeOK(SchemaGrammar* const currentGrammar,
    180                             const ContentSpecNode* const derivedSpecNode,
    181                             const int derivedScope,
    182                             const ContentSpecNode* const baseSpecNode,
    183                             const int baseScope,
    184                             const ComplexTypeInfo* const baseInfo = 0);
    185     SchemaElementDecl* findElement(const int scope,
    186                                    const unsigned int uriIndex,
    187                                    const XMLCh* const name,
    188                                    SchemaGrammar* const grammar,
    189                                    const ComplexTypeInfo* const typeInfo = 0);
    190     void checkICRestriction(const SchemaElementDecl* const derivedElemDecl,
    191                             const SchemaElementDecl* const baseElemDecl,
    192                             const XMLCh* const derivedElemName,
    193                             const XMLCh* const baseElemName);
    194     void checkTypesOK(const SchemaElementDecl* const derivedElemDecl,
    195                       const SchemaElementDecl* const baseElemDecl,
    196                       const XMLCh* const derivedElemName);
    197     void checkRecurseAsIfGroup(SchemaGrammar* const currentGrammar,
    198                                ContentSpecNode* const derivedSpecNode,
    199                                const int derivedScope,
    200                                const ContentSpecNode* const baseSpecNode,
    201                                const int baseScope,
    202                                ValueVectorOf<ContentSpecNode*>* const nodes,
    203                                const ComplexTypeInfo* const baseInfo);
    204     void checkRecurse(SchemaGrammar* const currentGrammar,
    205                       const ContentSpecNode* const derivedSpecNode,
    206                       const int derivedScope,
    207                       ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    208                       const ContentSpecNode* const baseSpecNode,
    209                       const int baseScope,
    210                       ValueVectorOf<ContentSpecNode*>* const baseNodes,
    211                       const ComplexTypeInfo* const baseInfo,
    212                       const bool toLax = false);
    213     void checkNSSubset(const ContentSpecNode* const derivedSpecNode,
    214                        const ContentSpecNode* const baseSpecNode);
    215     bool checkNSSubsetChoiceRoot(const ContentSpecNode* const derivedSpecNode,
    216                        const ContentSpecNode* const baseSpecNode);
    217     bool checkNSSubsetChoice(const ContentSpecNode* const derivedSpecNode,
    218                        const ContentSpecNode* const baseSpecNode);
    219     bool isWildCardEltSubset(const ContentSpecNode* const derivedSpecNode,
    220                              const ContentSpecNode* const baseSpecNode);
    221     void checkNSRecurseCheckCardinality(SchemaGrammar* const currentGrammar,
    222                                         const ContentSpecNode* const derivedSpecNode,
    223                                         ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    224                                         const int derivedScope,
    225                                         ContentSpecNode* const baseSpecNode,
    226                                         const bool toCheckOccurence);
    227     void checkRecurseUnordered(SchemaGrammar* const currentGrammar,
    228                                const ContentSpecNode* const derivedSpecNode,
    229                                ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    230                                const int derivedScope,
    231                                ContentSpecNode* const baseSpecNode,
    232                                ValueVectorOf<ContentSpecNode*>* const baseNodes,
    233                                const int baseScope,
    234                                const ComplexTypeInfo* const baseInfo);
    235     void checkMapAndSum(SchemaGrammar* const currentGrammar,
    236                         const ContentSpecNode* const derivedSpecNode,
    237                         ValueVectorOf<ContentSpecNode*>* const derivedNodes,
    238                         const int derivedScope,
    239                         ContentSpecNode* const baseSpecNode,
    240                         ValueVectorOf<ContentSpecNode*>* const baseNodes,
    241                         const int baseScope,
    242                         const ComplexTypeInfo* const baseInfo);
    243     ContentSpecNode* getNonUnaryGroup(ContentSpecNode* const pNode);
    244 
    245     // -----------------------------------------------------------------------
    246     //  Private data members
    247     //
    248     // -----------------------------------------------------------------------
    249     //  The following comes from or set by the Scanner
    250     //  fSchemaGrammar
    251     //      The current schema grammar used by the validator
    252     //
    253     //  fGrammarResolver
    254     //      All the schema grammar stored
    255     //
    256     //  fXsiType
    257     //      Store the Schema Type Attribute Value if schema type is specified
    258     //
    259     //  fNil
    260     //      Indicates if a nil value is acceptable
    261     //  fNilFound
    262     //      Indicates if Nillable has been set
    263     // -----------------------------------------------------------------------
    264     //  The following used internally in the validator
    265     //
    266     //  fCurrentDatatypeValidator
    267     //      The validator used for validating the content of elements
    268     //      with simple types
    269     //
    270     //  fDatatypeBuffer
    271     //      Buffer for simple type element string content
    272     //
    273     //  fTrailing
    274     //      Previous chunk had a trailing space
    275     //
    276     //  fSeenNonWhiteSpace
    277     //      Seen a non-whitespace character in the previous chunk
    278     //
    279     //  fSeenId
    280     //      Indicate if an attribute of ID type has been seen already, reset per element.
    281     //
    282     //  fSchemaErrorReporter
    283     //      Report schema process errors
    284     //
    285     //  fTypeStack
    286     //      Stack of complex type declarations.
    287     //
    288     //  fMostRecentAttrValidator
    289     //      DatatypeValidator that validated attribute most recently processed
    290     //
    291     //  fErrorOccurred
    292     //      whether an error occurred in the most recent operation
    293     // -----------------------------------------------------------------------
    294     MemoryManager*                  fMemoryManager;
    295     SchemaGrammar*                  fSchemaGrammar;
    296     GrammarResolver*                fGrammarResolver;
    297     QName*                          fXsiType;
    298     bool                            fNil;
    299     bool                            fNilFound;
    300     DatatypeValidator*              fCurrentDatatypeValidator;
    301     XMLBuffer*                      fNotationBuf;
    302     XMLBuffer                       fDatatypeBuffer;
    303     bool                            fTrailing;
    304     bool                            fSeenNonWhiteSpace;
    305     bool                            fSeenId;
    306     XSDErrorReporter                fSchemaErrorReporter;
    307     ValueStackOf<ComplexTypeInfo*>* fTypeStack;
    308     DatatypeValidator *             fMostRecentAttrValidator;
    309     bool                            fErrorOccurred;
    310     bool                            fElemIsSpecified;
    311 };
    312 
    313 
    314 // ---------------------------------------------------------------------------
    315 //  SchemaValidator: Setter methods
    316 // ---------------------------------------------------------------------------
    317 inline void SchemaValidator::setGrammarResolver(GrammarResolver* grammarResolver) {
    318     fGrammarResolver = grammarResolver;
    319 }
    320 
    321 inline void SchemaValidator::setXsiType(const XMLCh* const        prefix
    322       , const XMLCh* const        localPart
    323        , const unsigned int        uriId)
    324 {
    325     delete fXsiType;
    326     fXsiType = new (fMemoryManager) QName(prefix, localPart, uriId, fMemoryManager);
    327 }
    328 
    329 inline void SchemaValidator::setNillable(bool isNil) {
    330     fNil = isNil;
    331     fNilFound = true;
    332 }
    333 
    334 inline void SchemaValidator::resetNillable() {
    335     fNil = false;
    336     fNilFound = false;
    337 }
    338 
    339 inline void SchemaValidator::setExitOnFirstFatal(const bool newValue) {
    340 
    341     fSchemaErrorReporter.setExitOnFirstFatal(newValue);
    342 }
    343 
    344 inline void SchemaValidator::setDatatypeBuffer(const XMLCh* const value)
    345 {
    346     fDatatypeBuffer.append(value);
    347 }
    348 
    349 inline void SchemaValidator::clearDatatypeBuffer()
    350 {
    351     fDatatypeBuffer.reset();
    352 }
    353 
    354 // ---------------------------------------------------------------------------
    355 //  SchemaValidator: Getter methods
    356 // ---------------------------------------------------------------------------
    357 inline ComplexTypeInfo* SchemaValidator::getCurrentTypeInfo() const {
    358     if (fTypeStack->empty())
    359         return 0;
    360     return fTypeStack->peek();
    361 }
    362 
    363 inline DatatypeValidator * SchemaValidator::getCurrentDatatypeValidator() const
    364 {
    365     return fCurrentDatatypeValidator;
    366 }
    367 inline DatatypeValidator *SchemaValidator::getMostRecentAttrValidator() const
    368 {
    369     return fMostRecentAttrValidator;
    370 }
    371 
    372 // ---------------------------------------------------------------------------
    373 //  Virtual interface
    374 // ---------------------------------------------------------------------------
    375 inline Grammar* SchemaValidator::getGrammar() const {
    376     return fSchemaGrammar;
    377 }
    378 
    379 inline void SchemaValidator::setGrammar(Grammar* aGrammar) {
    380     fSchemaGrammar = (SchemaGrammar*) aGrammar;
    381 }
    382 
    383 inline void SchemaValidator::setErrorReporter(XMLErrorReporter* const errorReporter) {
    384 
    385     XMLValidator::setErrorReporter(errorReporter);
    386     fSchemaErrorReporter.setErrorReporter(errorReporter);
    387 }
    388 
    389 // ---------------------------------------------------------------------------
    390 //  SchemaValidator: DTD handler interface
    391 // ---------------------------------------------------------------------------
    392 inline bool SchemaValidator::handlesDTD() const
    393 {
    394     // No DTD scanning
    395     return false;
    396 }
    397 
    398 // ---------------------------------------------------------------------------
    399 //  SchemaValidator: Schema handler interface
    400 // ---------------------------------------------------------------------------
    401 inline bool SchemaValidator::handlesSchema() const
    402 {
    403     return true;
    404 }
    405 
    406 // ---------------------------------------------------------------------------
    407 //  SchemaValidator: Particle derivation checking
    408 // ---------------------------------------------------------------------------
    409 inline bool
    410 SchemaValidator::isOccurrenceRangeOK(const int min1, const int max1,
    411                                      const int min2, const int max2) {
    412 
    413     if (min1 >= min2 &&
    414         (max2 == SchemaSymbols::XSD_UNBOUNDED ||
    415          (max1 != SchemaSymbols::XSD_UNBOUNDED && max1 <= max2))) {
    416         return true;
    417     }
    418     return false;
    419 }
    420 
    421 inline bool SchemaValidator::getErrorOccurred() const
    422 {
    423     return fErrorOccurred;
    424 }
    425 
    426 inline bool SchemaValidator::getIsElemSpecified() const
    427 {
    428     return fElemIsSpecified;
    429 }
    430 
    431 inline const XMLCh* SchemaValidator::getNormalizedValue() const
    432 {
    433     return fDatatypeBuffer.getRawBuffer();
    434 }
    435 
    436 inline bool SchemaValidator::getIsXsiTypeSet() const
    437 {
    438     return (fXsiType!=0);
    439 }
    440 
    441 XERCES_CPP_NAMESPACE_END
    442 
    443 #endif
     1#include <icxercesc/validators/schema/SchemaValidator.hpp>
  • icXML/icXML-devel/src/xercesc/validators/schema/SubstitutionGroupComparator.cpp

    r2736 r2747  
    1 /*
    2  * Licensed to the Apache Software Foundation (ASF) under one or more
    3  * contributor license agreements.  See the NOTICE file distributed with
    4  * this work for additional information regarding copyright ownership.
    5  * The ASF licenses this file to You under the Apache License, Version 2.0
    6  * (the "License"); you may not use this file except in compliance with
    7  * the License.  You may obtain a copy of the License at
    8  *
    9  *      http://www.apache.org/licenses/LICENSE-2.0
    10  *
    11  * Unless required by applicable law or agreed to in writing, software
    12  * distributed under the License is distributed on an "AS IS" BASIS,
    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  * See the License for the specific language governing permissions and
    15  * limitations under the License.
    16  */
    17 
    18 /*
    19  * $Id: SubstitutionGroupComparator.cpp 794273 2009-07-15 14:13:07Z amassari $
    20  */
    21 
    22 
    23 // ---------------------------------------------------------------------------
    24 //  Includes
    25 // ---------------------------------------------------------------------------
    26 #include <icxercesc/framework/XMLGrammarPool.hpp>
    27 #include <xercesc/framework/XMLSchemaDescription.hpp>
    28 #include <xercesc/framework/psvi/XSAnnotation.hpp>
    29 #include <icxercesc/validators/schema/SubstitutionGroupComparator.hpp>
    30 #include <xercesc/validators/common/Grammar.hpp>
    31 #include <xercesc/validators/schema/SchemaGrammar.hpp>
    32 #include <icxercesc/validators/schema/ComplexTypeInfo.hpp>
    33 #include <icxercesc/validators/schema/SchemaSymbols.hpp>
    34 
    35 XERCES_CPP_NAMESPACE_BEGIN
    36 
    37 bool SubstitutionGroupComparator::isEquivalentTo(const QName* const anElement
    38                                                , const QName* const exemplar)
    39 {
    40     if (!anElement && !exemplar)
    41         return true;
    42 
    43     if ((!anElement && exemplar) || (anElement && !exemplar))
    44         return false;
    45 
    46 
    47     if (XMLString::equals(anElement->getLocalPart(), exemplar->getLocalPart()) &&
    48         (anElement->getURI() == exemplar->getURI()))
    49         return true; // they're the same!
    50 
    51     if (!fGrammarResolver || !fStringPool )
    52     {
    53         ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::SubGrpComparator_NGR, anElement->getMemoryManager());
    54     }
    55 
    56     unsigned int uriId = anElement->getURI();
    57     if (uriId == XMLContentModel::gEOCFakeId ||
    58         uriId == XMLContentModel::gEpsilonFakeId ||
    59         uriId == XMLElementDecl::fgPCDataElemId ||
    60         uriId == XMLElementDecl::fgInvalidElemId)
    61         return false;
    62 
    63     const XMLCh* uri = fStringPool->getValueForId(uriId);
    64     const XMLCh* localpart = anElement->getLocalPart();
    65 
    66     // In addition to simply trying to find a chain between anElement and exemplar,
    67     // we need to make sure that no steps in the chain are blocked.
    68     // That is, at every step, we need to make sure that the element
    69     // being substituted for will permit being substituted
    70     // for, and whether the type of the element will permit derivations in
    71     // instance documents of this sort.
    72 
    73     if (!uri)
    74         return false;
    75 
    76     SchemaGrammar *sGrammar = (SchemaGrammar*) fGrammarResolver->getGrammar(uri);
    77     if (!sGrammar || sGrammar->getGrammarType() == Grammar::DTDGrammarType)
    78         return false;
    79 
    80     SchemaElementDecl* anElementDecl = (SchemaElementDecl*) sGrammar->getElemDecl(uriId, localpart, 0, Grammar::TOP_LEVEL_SCOPE);
    81     if (!anElementDecl)
    82         return false;
    83 
    84     SchemaElementDecl* pElemDecl = anElementDecl->getSubstitutionGroupElem();
    85     bool foundIt = false;
    86 
    87     while (pElemDecl) //(substitutionGroupFullName)
    88     {
    89         if (XMLString::equals(pElemDecl->getBaseName(), exemplar->getLocalPart()) &&
    90             (pElemDecl->getURI() == exemplar->getURI()))
    91         {
    92             // time to check for block value on element
    93             if((pElemDecl->getBlockSet() & SchemaSymbols::XSD_SUBSTITUTION) != 0)
    94                 return false;
    95 
    96             foundIt = true;
    97             break;
    98         }
    99 
    100         pElemDecl = pElemDecl->getSubstitutionGroupElem();
    101     }//while
    102 
    103     if (!foundIt)
    104         return false;
    105 
    106     // this will contain anElement's complexType information.
    107     ComplexTypeInfo *aComplexType = anElementDecl->getComplexTypeInfo();
    108     int exemplarBlockSet = pElemDecl->getBlockSet();
    109 
    110     if(!aComplexType)
    111     {
    112         // check on simpleType case
    113         DatatypeValidator *anElementDV = anElementDecl->getDatatypeValidator();
    114         DatatypeValidator *exemplarDV = pElemDecl->getDatatypeValidator();
    115 
    116         return((anElementDV == 0) ||
    117             ((anElementDV == exemplarDV) ||
    118             ((exemplarBlockSet & SchemaSymbols::XSD_RESTRICTION) == 0)));
    119     }
    120 
    121     // 2.3 The set of all {derivation method}s involved in the derivation of D's {type definition} from C's {type definition} does not intersect with the union of the blocking constraint, C's {prohibited substitutions} (if C is complex, otherwise the empty set) and the {prohibited substitutions} (respectively the empty set) of any intermediate {type definition}s in the derivation of D's {type definition} from C's {type definition}.
    122     // prepare the combination of {derivation method} and
    123     // {disallowed substitution}
    124     int devMethod = 0;
    125     int blockConstraint = exemplarBlockSet;
    126 
    127     ComplexTypeInfo *exemplarComplexType = pElemDecl->getComplexTypeInfo();
    128     ComplexTypeInfo *tempType = aComplexType;;
    129 
    130     while (tempType != 0 &&
    131         tempType != exemplarComplexType)
    132     {
    133         devMethod |= tempType->getDerivedBy();
    134         tempType = tempType->getBaseComplexTypeInfo();
    135         if (tempType) {
    136             blockConstraint |= tempType->getBlockSet();
    137         }
    138     }
    139     if (tempType != exemplarComplexType) {
    140         return false;
    141     }
    142     if ((devMethod & blockConstraint) != 0) {
    143         return false;
    144     }
    145 
    146     return true;
    147 }
    148 
    149 
    150 bool SubstitutionGroupComparator::isAllowedByWildcard(SchemaGrammar* const pGrammar,
    151                                                       QName* const element,
    152                                                       unsigned int wuri, bool wother)
    153 {
    154     // whether the uri is allowed directly by the wildcard
    155     unsigned int uriId = element->getURI();
    156 
    157     // Here we assume that empty string has id 1.
    158     //
    159     if ((!wother && uriId == wuri) ||
    160         (wother &&
    161          uriId != 1 &&
    162          uriId != wuri &&
    163          uriId != XMLContentModel::gEOCFakeId &&
    164          uriId != XMLContentModel::gEpsilonFakeId &&
    165          uriId != XMLElementDecl::fgPCDataElemId &&
    166          uriId != XMLElementDecl::fgInvalidElemId))
    167     {
    168         return true;
    169     }
    170 
    171     // get all elements that can substitute the current element
    172     RefHash2KeysTableOf<ElemVector>* theValidSubstitutionGroups = pGrammar->getValidSubstitutionGroups();
    173 
    174     if (!theValidSubstitutionGroups)
    175         return false;
    176 
    177     ValueVectorOf<SchemaElementDecl*>* subsElements = theValidSubstitutionGroups->get(element->getLocalPart(), uriId);
    178 
    179     if (!subsElements)
    180         return false;
    181 
    182     // then check whether there exists one element that is allowed by the wildcard
    183     XMLSize_t size = subsElements->size();
    184 
    185     for (XMLSize_t i = 0; i < size; i++)
    186     {
    187         unsigned int subUriId = subsElements->elementAt(i)->getElementName()->getURI();
    188 
    189         // Here we assume that empty string has id 1.
    190         //
    191         if ((!wother && subUriId == wuri) ||
    192             (wother &&
    193              subUriId != 1 &&
    194              subUriId != wuri &&
    195              subUriId != XMLContentModel::gEOCFakeId &&
    196              subUriId != XMLContentModel::gEpsilonFakeId &&
    197              subUriId != XMLElementDecl::fgPCDataElemId &&
    198              subUriId != XMLElementDecl::fgInvalidElemId))
    199         {
    200             return true;
    201         }
    202     }
    203     return false;
    204 }
    205 
    206 XERCES_CPP_NAMESPACE_END
    207 
    208 /**
    209   * End of file SubstitutionGroupComparator.cpp
    210   */
     1#include <icxercesc/validators/schema/SubstitutionGroupComparator.cpp>
  • icXML/icXML-devel/src/xercesc/validators/schema/SubstitutionGroupComparator.hpp

    r2722 r2747  
    1 /*
    2  * Licensed to the Apache Software Foundation (ASF) under one or more
    3  * contributor license agreements.  See the NOTICE file distributed with
    4  * this work for additional information regarding copyright ownership.
    5  * The ASF licenses this file to You under the Apache License, Version 2.0
    6  * (the "License"); you may not use this file except in compliance with
    7  * the License.  You may obtain a copy of the License at
    8  *
    9  *      http://www.apache.org/licenses/LICENSE-2.0
    10  *
    11  * Unless required by applicable law or agreed to in writing, software
    12  * distributed under the License is distributed on an "AS IS" BASIS,
    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  * See the License for the specific language governing permissions and
    15  * limitations under the License.
    16  */
    17 
    18 /*
    19  * $Id: SubstitutionGroupComparator.hpp 932887 2010-04-11 13:04:59Z borisk $
    20  */
    21 
    22 #if !defined(XERCESC_INCLUDE_GUARD_SUBSTITUTIONGROUPCOMPARATOR_HPP)
    23 #define XERCESC_INCLUDE_GUARD_SUBSTITUTIONGROUPCOMPARATOR_HPP
    24 
    25 #include <xercesc/util/StringPool.hpp>
    26 #include <icxercesc/util/QName.hpp>
    27 #include <icxercesc/validators/common/GrammarResolver.hpp>
    28 
    29 XERCES_CPP_NAMESPACE_BEGIN
    30 
    31 class SchemaGrammar;
    32 
    33 class VALIDATORS_EXPORT SubstitutionGroupComparator : public XMemory
    34 {
    35 public:
    36 
    37     // -----------------------------------------------------------------------
    38     //  Public Constructor
    39     // -----------------------------------------------------------------------
    40     /** @name Constructor. */
    41     //@{
    42 
    43     SubstitutionGroupComparator(GrammarResolver*  const pGrammarResolver
    44                               , XMLStringPool*    const pStringPool);
    45 
    46 
    47     //@}
    48 
    49     // -----------------------------------------------------------------------
    50     //  Public Destructor
    51     // -----------------------------------------------------------------------
    52     /** @name Destructor. */
    53     //@{
    54 
    55     ~SubstitutionGroupComparator();
    56 
    57     //@}
    58 
    59     // -----------------------------------------------------------------------
    60     // Validation methods
    61     // -----------------------------------------------------------------------
    62     /** @name Validation Function */
    63     //@{
    64 
    65     /**
    66            * Checks that the "anElement" is within the substitution group.
    67            *
    68            * @param  anElement   QName of the element
    69            *
    70            * @param  exemplar     QName of the head element in the group
    71            */
    72     bool isEquivalentTo(const QName* const anElement
    73                       , const QName* const exemplar);
    74          //@}
    75 
    76     /*
    77      * check whether one element or any element in its substitution group
    78      * is allowed by a given wildcard uri
    79      *
    80      * @param pGrammar the grammar where the wildcard is declared
    81      * @param element  the QName of a given element
    82      * @param wuri     the uri of the wildcard
    83      * @param wother   whether the uri is from ##other, so wuri is excluded
    84      *
    85      * @return whether the element is allowed by the wildcard
    86      */
    87     bool isAllowedByWildcard(SchemaGrammar* const pGrammar, QName* const element, unsigned int wuri, bool wother);
    88 
    89 private:
    90     // -----------------------------------------------------------------------
    91     //  Unimplemented constructors and operators
    92     // -----------------------------------------------------------------------
    93     SubstitutionGroupComparator();
    94     SubstitutionGroupComparator(const SubstitutionGroupComparator&);
    95     SubstitutionGroupComparator& operator=(const SubstitutionGroupComparator&);
    96    
    97     // -----------------------------------------------------------------------
    98     //  Private data members
    99     //
    100     //
    101     // -----------------------------------------------------------------------
    102     GrammarResolver     *fGrammarResolver;
    103     XMLStringPool       *fStringPool;
    104 };
    105 
    106 
    107 // ---------------------------------------------------------------------------
    108 //  SubstitutionGroupComparator: Getters
    109 // ---------------------------------------------------------------------------
    110 inline SubstitutionGroupComparator::SubstitutionGroupComparator(GrammarResolver*  const pGrammarResolver
    111                                                               , XMLStringPool*    const pStringPool)
    112 :fGrammarResolver(pGrammarResolver)
    113 ,fStringPool(pStringPool)
    114 {}
    115 
    116 inline SubstitutionGroupComparator::~SubstitutionGroupComparator()
    117 {}
    118 
    119 XERCES_CPP_NAMESPACE_END
    120 
    121 #endif
    122 
    123 /**
    124   * End of file SubstitutionGroupComparator.hpp
    125   */
    126 
     1#include <icxercesc/validators/schema/SubstitutionGroupComparator.hpp>
Note: See TracChangeset for help on using the changeset viewer.