Changeset 2779


Ignore:
Timestamp:
Dec 15, 2012, 8:06:34 PM (7 years ago)
Author:
cameron
Message:

Synchronize files with IC svn

Location:
icXML/icXML-devel/src
Files:
4 added
13 deleted
10 edited

Legend:

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

    r2777 r2779  
    909909        xercesc/validators/DTD/XMLDTDDescriptionImpl.hpp \
    910910        icxercesc/validators/schema/ComplexTypeInfo.hpp \
    911         xercesc/validators/schema/GeneralAttributeCheck.hpp \
     911        icxercesc/validators/schema/GeneralAttributeCheck.hpp \
    912912        xercesc/validators/schema/identity/FieldActivator.hpp \
    913913        xercesc/validators/schema/identity/FieldValueMap.hpp \
     
    928928        xercesc/validators/schema/NamespaceScope.hpp \
    929929        xercesc/validators/schema/PSVIDefs.hpp \
    930         xercesc/validators/schema/SchemaAttDef.hpp \
     930        icxercesc/validators/schema/SchemaAttDef.hpp \
    931931        xercesc/validators/schema/SchemaAttDefList.hpp \
    932932        xercesc/validators/schema/SchemaElementDecl.hpp \
     
    10011001        xercesc/validators/DTD/XMLDTDDescriptionImpl.cpp \
    10021002        icxercesc/validators/schema/ComplexTypeInfo.cpp \
    1003         xercesc/validators/schema/GeneralAttributeCheck.cpp \
     1003        icxercesc/validators/schema/GeneralAttributeCheck.cpp \
    10041004        xercesc/validators/schema/identity/FieldActivator.cpp \
    10051005        xercesc/validators/schema/identity/FieldValueMap.cpp \
     
    10181018        xercesc/validators/schema/identity/XPathSymbols.cpp \
    10191019        xercesc/validators/schema/NamespaceScope.cpp \
    1020         xercesc/validators/schema/SchemaAttDef.cpp \
     1020        icxercesc/validators/schema/SchemaAttDef.cpp \
    10211021        xercesc/validators/schema/SchemaAttDefList.cpp \
    10221022        xercesc/validators/schema/SchemaElementDecl.cpp \
  • icXML/icXML-devel/src/Makefile.in

    r2777 r2779  
    413413        xercesc/validators/DTD/XMLDTDDescriptionImpl.cpp \
    414414        icxercesc/validators/schema/ComplexTypeInfo.cpp \
    415         xercesc/validators/schema/GeneralAttributeCheck.cpp \
     415        icxercesc/validators/schema/GeneralAttributeCheck.cpp \
    416416        xercesc/validators/schema/identity/FieldActivator.cpp \
    417417        xercesc/validators/schema/identity/FieldValueMap.cpp \
     
    430430        xercesc/validators/schema/identity/XPathSymbols.cpp \
    431431        xercesc/validators/schema/NamespaceScope.cpp \
    432         xercesc/validators/schema/SchemaAttDef.cpp \
     432        icxercesc/validators/schema/SchemaAttDef.cpp \
    433433        xercesc/validators/schema/SchemaAttDefList.cpp \
    434434        xercesc/validators/schema/SchemaElementDecl.cpp \
     
    709709        xercesc/validators/DTD/XMLDTDDescriptionImpl.lo \
    710710        icxercesc/validators/schema/ComplexTypeInfo.lo \
    711         xercesc/validators/schema/GeneralAttributeCheck.lo \
     711        icxercesc/validators/schema/GeneralAttributeCheck.lo \
    712712        xercesc/validators/schema/identity/FieldActivator.lo \
    713713        xercesc/validators/schema/identity/FieldValueMap.lo \
     
    726726        xercesc/validators/schema/identity/XPathSymbols.lo \
    727727        xercesc/validators/schema/NamespaceScope.lo \
    728         xercesc/validators/schema/SchemaAttDef.lo \
     728        icxercesc/validators/schema/SchemaAttDef.lo \
    729729        xercesc/validators/schema/SchemaAttDefList.lo \
    730730        xercesc/validators/schema/SchemaElementDecl.lo \
     
    11941194        xercesc/validators/DTD/XMLDTDDescriptionImpl.hpp \
    11951195        icxercesc/validators/schema/ComplexTypeInfo.hpp \
    1196         xercesc/validators/schema/GeneralAttributeCheck.hpp \
     1196        icxercesc/validators/schema/GeneralAttributeCheck.hpp \
    11971197        xercesc/validators/schema/identity/FieldActivator.hpp \
    11981198        xercesc/validators/schema/identity/FieldValueMap.hpp \
     
    12131213        xercesc/validators/schema/NamespaceScope.hpp \
    12141214        xercesc/validators/schema/PSVIDefs.hpp \
    1215         xercesc/validators/schema/SchemaAttDef.hpp \
     1215        icxercesc/validators/schema/SchemaAttDef.hpp \
    12161216        xercesc/validators/schema/SchemaAttDefList.hpp \
    12171217        xercesc/validators/schema/SchemaElementDecl.hpp \
     
    22242224        xercesc/validators/DTD/XMLDTDDescriptionImpl.hpp \
    22252225        icxercesc/validators/schema/ComplexTypeInfo.hpp \
    2226         xercesc/validators/schema/GeneralAttributeCheck.hpp \
     2226        icxercesc/validators/schema/GeneralAttributeCheck.hpp \
    22272227        xercesc/validators/schema/identity/FieldActivator.hpp \
    22282228        xercesc/validators/schema/identity/FieldValueMap.hpp \
     
    22432243        xercesc/validators/schema/NamespaceScope.hpp \
    22442244        xercesc/validators/schema/PSVIDefs.hpp \
    2245         xercesc/validators/schema/SchemaAttDef.hpp \
     2245        icxercesc/validators/schema/SchemaAttDef.hpp \
    22462246        xercesc/validators/schema/SchemaAttDefList.hpp \
    22472247        xercesc/validators/schema/SchemaElementDecl.hpp \
     
    23162316        xercesc/validators/DTD/XMLDTDDescriptionImpl.cpp \
    23172317        icxercesc/validators/schema/ComplexTypeInfo.cpp \
    2318         xercesc/validators/schema/GeneralAttributeCheck.cpp \
     2318        icxercesc/validators/schema/GeneralAttributeCheck.cpp \
    23192319        xercesc/validators/schema/identity/FieldActivator.cpp \
    23202320        xercesc/validators/schema/identity/FieldValueMap.cpp \
     
    23332333        xercesc/validators/schema/identity/XPathSymbols.cpp \
    23342334        xercesc/validators/schema/NamespaceScope.cpp \
    2335         xercesc/validators/schema/SchemaAttDef.cpp \
     2335        icxercesc/validators/schema/SchemaAttDef.cpp \
    23362336        xercesc/validators/schema/SchemaAttDefList.cpp \
    23372337        xercesc/validators/schema/SchemaElementDecl.cpp \
     
    33563356        icxercesc/validators/schema/$(am__dirstamp) \
    33573357        icxercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
    3358 xercesc/validators/schema/$(am__dirstamp):
    3359         @$(MKDIR_P) xercesc/validators/schema
    3360         @: > xercesc/validators/schema/$(am__dirstamp)
    3361 xercesc/validators/schema/$(DEPDIR)/$(am__dirstamp):
    3362         @$(MKDIR_P) xercesc/validators/schema/$(DEPDIR)
    3363         @: > xercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
    3364 xercesc/validators/schema/GeneralAttributeCheck.lo:  \
    3365         xercesc/validators/schema/$(am__dirstamp) \
    3366         xercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
     3358icxercesc/validators/schema/GeneralAttributeCheck.lo:  \
     3359        icxercesc/validators/schema/$(am__dirstamp) \
     3360        icxercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
    33673361xercesc/validators/schema/identity/$(am__dirstamp):
    33683362        @$(MKDIR_P) xercesc/validators/schema/identity
     
    34163410        xercesc/validators/schema/identity/$(am__dirstamp) \
    34173411        xercesc/validators/schema/identity/$(DEPDIR)/$(am__dirstamp)
     3412xercesc/validators/schema/$(am__dirstamp):
     3413        @$(MKDIR_P) xercesc/validators/schema
     3414        @: > xercesc/validators/schema/$(am__dirstamp)
     3415xercesc/validators/schema/$(DEPDIR)/$(am__dirstamp):
     3416        @$(MKDIR_P) xercesc/validators/schema/$(DEPDIR)
     3417        @: > xercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
    34183418xercesc/validators/schema/NamespaceScope.lo:  \
    34193419        xercesc/validators/schema/$(am__dirstamp) \
    34203420        xercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
    3421 xercesc/validators/schema/SchemaAttDef.lo:  \
    3422         xercesc/validators/schema/$(am__dirstamp) \
    3423         xercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
     3421icxercesc/validators/schema/SchemaAttDef.lo:  \
     3422        icxercesc/validators/schema/$(am__dirstamp) \
     3423        icxercesc/validators/schema/$(DEPDIR)/$(am__dirstamp)
    34243424xercesc/validators/schema/SchemaAttDefList.lo:  \
    34253425        xercesc/validators/schema/$(am__dirstamp) \
     
    37503750        -rm -f icxercesc/validators/schema/ComplexTypeInfo.$(OBJEXT)
    37513751        -rm -f icxercesc/validators/schema/ComplexTypeInfo.lo
     3752        -rm -f icxercesc/validators/schema/GeneralAttributeCheck.$(OBJEXT)
     3753        -rm -f icxercesc/validators/schema/GeneralAttributeCheck.lo
     3754        -rm -f icxercesc/validators/schema/SchemaAttDef.$(OBJEXT)
     3755        -rm -f icxercesc/validators/schema/SchemaAttDef.lo
    37523756        -rm -f icxercesc/validators/schema/SchemaSymbols.$(OBJEXT)
    37533757        -rm -f icxercesc/validators/schema/SchemaSymbols.lo
     
    42284232        -rm -f xercesc/validators/datatype/YearMonthDatatypeValidator.$(OBJEXT)
    42294233        -rm -f xercesc/validators/datatype/YearMonthDatatypeValidator.lo
    4230         -rm -f xercesc/validators/schema/GeneralAttributeCheck.$(OBJEXT)
    4231         -rm -f xercesc/validators/schema/GeneralAttributeCheck.lo
    42324234        -rm -f xercesc/validators/schema/NamespaceScope.$(OBJEXT)
    42334235        -rm -f xercesc/validators/schema/NamespaceScope.lo
    4234         -rm -f xercesc/validators/schema/SchemaAttDef.$(OBJEXT)
    4235         -rm -f xercesc/validators/schema/SchemaAttDef.lo
    42364236        -rm -f xercesc/validators/schema/SchemaAttDefList.$(OBJEXT)
    42374237        -rm -f xercesc/validators/schema/SchemaAttDefList.lo
     
    43504350@AMDEP_TRUE@@am__include@ @am__quote@icxercesc/validators/datatype/$(DEPDIR)/QNameDatatypeValidator.Plo@am__quote@
    43514351@AMDEP_TRUE@@am__include@ @am__quote@icxercesc/validators/schema/$(DEPDIR)/ComplexTypeInfo.Plo@am__quote@
     4352@AMDEP_TRUE@@am__include@ @am__quote@icxercesc/validators/schema/$(DEPDIR)/GeneralAttributeCheck.Plo@am__quote@
     4353@AMDEP_TRUE@@am__include@ @am__quote@icxercesc/validators/schema/$(DEPDIR)/SchemaAttDef.Plo@am__quote@
    43524354@AMDEP_TRUE@@am__include@ @am__quote@icxercesc/validators/schema/$(DEPDIR)/SchemaSymbols.Plo@am__quote@
    43534355@AMDEP_TRUE@@am__include@ @am__quote@icxercesc/validators/schema/$(DEPDIR)/SchemaValidator.Plo@am__quote@
     
    45894591@AMDEP_TRUE@@am__include@ @am__quote@xercesc/validators/datatype/$(DEPDIR)/YearDatatypeValidator.Plo@am__quote@
    45904592@AMDEP_TRUE@@am__include@ @am__quote@xercesc/validators/datatype/$(DEPDIR)/YearMonthDatatypeValidator.Plo@am__quote@
    4591 @AMDEP_TRUE@@am__include@ @am__quote@xercesc/validators/schema/$(DEPDIR)/GeneralAttributeCheck.Plo@am__quote@
    45924593@AMDEP_TRUE@@am__include@ @am__quote@xercesc/validators/schema/$(DEPDIR)/NamespaceScope.Plo@am__quote@
    4593 @AMDEP_TRUE@@am__include@ @am__quote@xercesc/validators/schema/$(DEPDIR)/SchemaAttDef.Plo@am__quote@
    45944594@AMDEP_TRUE@@am__include@ @am__quote@xercesc/validators/schema/$(DEPDIR)/SchemaAttDefList.Plo@am__quote@
    45954595@AMDEP_TRUE@@am__include@ @am__quote@xercesc/validators/schema/$(DEPDIR)/SchemaElementDecl.Plo@am__quote@
  • icXML/icXML-devel/src/icxercesc/validators/schema/ComplexTypeInfo.hpp

    r2740 r2779  
    3838#include <icxercesc/framework/XMLElementDecl.hpp>
    3939#include <icxercesc/framework/XMLContentModel.hpp>
    40 #include <xercesc/validators/schema/SchemaAttDef.hpp>
     40#include <icxercesc/validators/schema/SchemaAttDef.hpp>
    4141#include <xercesc/internal/XSerializable.hpp>
    4242#include <icxmlc/XMLConfig.hpp>
  • icXML/icXML-devel/src/xercesc/framework/psvi/XSAttributeDeclaration.cpp

    r2722 r2779  
    2626#include <xercesc/util/StringPool.hpp>
    2727#include <xercesc/validators/schema/SchemaGrammar.hpp>
    28 #include <xercesc/validators/schema/SchemaAttDef.hpp>
     28#include <icxercesc/validators/schema/SchemaAttDef.hpp>
    2929
    3030XERCES_CPP_NAMESPACE_BEGIN
  • icXML/icXML-devel/src/xercesc/framework/psvi/XSWildcard.cpp

    r2722 r2779  
    2525#include <xercesc/util/StringPool.hpp>
    2626#include <xercesc/validators/common/ContentSpecNode.hpp>
    27 #include <xercesc/validators/schema/SchemaAttDef.hpp>
     27#include <icxercesc/validators/schema/SchemaAttDef.hpp>
    2828
    2929XERCES_CPP_NAMESPACE_BEGIN
  • icXML/icXML-devel/src/xercesc/internal/XTemplateSerializer.hpp

    r2722 r2779  
    3838#include <icxercesc/validators/DTD/DTDElementDecl.hpp>
    3939#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
    40 #include <xercesc/validators/schema/SchemaAttDef.hpp>
     40#include <icxercesc/validators/schema/SchemaAttDef.hpp>
    4141#include <xercesc/validators/schema/SchemaElementDecl.hpp>
    4242#include <xercesc/validators/schema/XercesGroupInfo.hpp>
  • icXML/icXML-devel/src/xercesc/validators/schema/TraverseSchema.cpp

    r2774 r2779  
    4545#include <xercesc/framework/XMLSchemaDescription.hpp>
    4646#include <xercesc/validators/schema/identity/XPathException.hpp>
    47 #include <xercesc/validators/schema/GeneralAttributeCheck.hpp>
     47#include <icxercesc/validators/schema/GeneralAttributeCheck.hpp>
    4848#include <xercesc/validators/schema/XercesGroupInfo.hpp>
    4949#include <xercesc/validators/schema/XercesAttGroupInfo.hpp>
     
    6363XERCES_CPP_NAMESPACE_BEGIN
    6464
     65#ifdef PRINT_DEBUG_MESSAGE
     66#define DEBUG_SCHEMA_MESSAGE(x) // DEBUG_MESSAGE(x)
     67#else
     68#define DEBUG_SCHEMA_MESSAGE(x)
     69#endif
     70
     71IDISA_ALWAYS_INLINE
     72static unsigned int resolveUriId
     73(
     74        XMLNamespaceResolver * fUriResolver
     75        , const unsigned int fEmptyNamespaceURI
     76        , const XMLCh * uri
     77)
     78{
     79        unsigned int uriId = fEmptyNamespaceURI;
     80        if (likely(uri != NULL))
     81        {
     82                uriId = fUriResolver->resolveUriId(uri);
     83        }
     84        return uriId;
     85}
     86
     87#define RESOLVE_URI_ID(uri) resolveUriId(fUriResolver, fEmptyNamespaceURI, uri)
     88
    6589// ---------------------------------------------------------------------------
    6690//  TraverseSchema: Local declaration
     
    7195{
    7296public:
    73     NamespaceScopeManager(const DOMElement* const node, SchemaInfo* info, TraverseSchema* traverser)
    74     {
    75         fScopeAdded=node?traverser->retrieveNamespaceMapping(node):false;
    76         fSchemaInfo=info;
    77     }
    78     ~NamespaceScopeManager()
    79     {
    80         if(fScopeAdded)
    81             fSchemaInfo->getNamespaceScope()->decreaseDepth();
    82 
    83     }
     97        NamespaceScopeManager(const DOMElement* const node, SchemaInfo* info, TraverseSchema* traverser)
     98        {
     99                fScopeAdded = node ? traverser->retrieveNamespaceMapping(node) : false;
     100                fSchemaInfo = info;
     101        }
     102        ~NamespaceScopeManager()
     103        {
     104                if (fScopeAdded)
     105                {
     106                        fSchemaInfo->getNamespaceScope()->decreaseDepth();
     107                }
     108        }
    84109protected:
    85     bool        fScopeAdded;
    86     SchemaInfo* fSchemaInfo;
     110        bool        fScopeAdded;
     111        SchemaInfo* fSchemaInfo;
    87112};
    88113
     
    97122static const XMLCh fgAnonSNamePrefix[] =
    98123{
    99     chUnderscore, chUnderscore, chLatin_A, chLatin_n, chLatin_o, chLatin_n, chLatin_S, chNull
     124        chUnderscore, chUnderscore, chLatin_A, chLatin_n, chLatin_o, chLatin_n, chLatin_S, chNull
    100125};
    101126
    102127static const XMLCh fgAnonCNamePrefix[] =
    103128{
    104     chUnderscore, chUnderscore, chLatin_A, chLatin_n, chLatin_o, chLatin_n, chLatin_C, chNull
     129        chUnderscore, chUnderscore, chLatin_A, chLatin_n, chLatin_o, chLatin_n, chLatin_C, chNull
    105130};
    106131
    107132static const XMLCh fgUnbounded[] =
    108133{
    109     chLatin_u, chLatin_n, chLatin_b, chLatin_o, chLatin_u, chLatin_n, chLatin_d,
    110     chLatin_e, chLatin_d, chNull
     134        chLatin_u, chLatin_n, chLatin_b, chLatin_o, chLatin_u, chLatin_n, chLatin_d,
     135        chLatin_e, chLatin_d, chNull
    111136};
    112137
    113138static const XMLCh fgValueOne[] =
    114139{
    115     chDigit_1, chNull
     140        chDigit_1, chNull
    116141};
    117142
    118143static const XMLCh fgValueZero[] =
    119144{
    120     chDigit_0, chNull
     145        chDigit_0, chNull
    121146};
    122147
    123148static const XMLCh* fgIdentityConstraints[] =
    124149{
    125     SchemaSymbols::fgELT_UNIQUE,
    126     SchemaSymbols::fgELT_KEY,
    127     SchemaSymbols::fgELT_KEYREF
     150        SchemaSymbols::fgELT_UNIQUE,
     151        SchemaSymbols::fgELT_KEY,
     152        SchemaSymbols::fgELT_KEYREF
    128153};
    129154
    130155static const XMLCh fgSynthetic_Annotation[] =
    131156{
    132     chLatin_S, chLatin_y, chLatin_n, chLatin_t, chLatin_h, chLatin_e, chLatin_t
    133     ,   chLatin_i, chLatin_c, chUnderscore
    134     ,   chLatin_A, chLatin_n, chLatin_n, chLatin_o, chLatin_t, chLatin_a, chLatin_t
    135     ,   chLatin_i, chLatin_o, chLatin_n, chNull
     157        chLatin_S, chLatin_y, chLatin_n, chLatin_t, chLatin_h, chLatin_e, chLatin_t
     158        ,   chLatin_i, chLatin_c, chUnderscore
     159        ,   chLatin_A, chLatin_n, chLatin_n, chLatin_o, chLatin_t, chLatin_a, chLatin_t
     160        ,   chLatin_i, chLatin_o, chLatin_n, chNull
    136161};
    137162
     
    139164// Flags for global declaration
    140165enum {
    141     ENUM_ELT_SIMPLETYPE,
    142     ENUM_ELT_COMPLEXTYPE,
    143     ENUM_ELT_ELEMENT,
    144     ENUM_ELT_ATTRIBUTE,
    145     ENUM_ELT_ATTRIBUTEGROUP,
    146     ENUM_ELT_GROUP,
    147     ENUM_ELT_SIZE
     166        ENUM_ELT_SIMPLETYPE,
     167        ENUM_ELT_COMPLEXTYPE,
     168        ENUM_ELT_ELEMENT,
     169        ENUM_ELT_ATTRIBUTE,
     170        ENUM_ELT_ATTRIBUTEGROUP,
     171        ENUM_ELT_GROUP,
     172        ENUM_ELT_SIZE
    148173};
    149174
     
    154179// ---------------------------------------------------------------------------
    155180TraverseSchema::TraverseSchema( DOMElement* const    schemaRoot
    156                               , XMLStringPool* const   uriStringPool
    157                               , SchemaGrammar* const   schemaGrammar
    158                               , GrammarResolver* const grammarResolver
    159                               , RefHash2KeysTableOf<SchemaInfo>* cachedSchemaInfoList
    160                               , RefHash2KeysTableOf<SchemaInfo>* schemaInfoList
    161                               , XMLScanner* const      xmlScanner
    162                               , const XMLCh* const     schemaURL
    163                               , XMLEntityHandler* const  entityHandler
    164                               , XMLErrorReporter* const errorReporter
    165                               , MemoryManager* const    manager
    166                               , bool multipleImport)
    167     : fFullConstraintChecking(false)
    168     , fTargetNSURI(-1)
    169     , fEmptyNamespaceURI(-1)
    170     , fCurrentScope(Grammar::TOP_LEVEL_SCOPE)
    171     , fScopeCount(schemaGrammar->getScopeCount ())
    172     , fAnonXSTypeCount(schemaGrammar->getAnonTypeCount ())
    173     , fCircularCheckIndex(0)
    174     , fTargetNSURIString(0)
    175     , fDatatypeRegistry(0)
    176     , fGrammarResolver(grammarResolver)
    177     , fSchemaGrammar(schemaGrammar)
    178     , fEntityHandler(entityHandler)
    179     , fErrorReporter(errorReporter)
    180     , fURIStringPool(uriStringPool)
    181     , fStringPool(0)
    182     , fBuffer(1023, manager)
    183     , fScanner(xmlScanner)
    184     , fAttributeDeclRegistry(0)
    185     , fComplexTypeRegistry(0)
    186     , fGroupRegistry(0)
    187     , fAttGroupRegistry(0)
    188     , fIC_ElementsNS(0)
    189     , fPreprocessedNodes(0)
    190     , fSchemaInfo(0)
    191     , fCurrentGroupInfo(0)
    192     , fCurrentAttGroupInfo(0)
    193     , fCurrentComplexType(0)
    194     , fCurrentTypeNameStack(0)
    195     , fCurrentGroupStack(0)
    196     , fIC_Elements(0)
    197     , fDeclStack(0)
    198     , fGlobalDeclarations(0)
    199     , fNonXSAttList(0)
    200     , fImportedNSList(0)
    201     , fIC_NodeListNS(0)
    202     , fNotationRegistry(0)
    203     , fRedefineComponents(0)
    204     , fIdentityConstraintNames(0)
    205     , fValidSubstitutionGroups(0)
    206     , fSchemaInfoList(schemaInfoList)
    207     , fCachedSchemaInfoList (cachedSchemaInfoList)
    208     , fParser(0)
    209     , fLocator(0)
    210     , fMemoryManager(manager)
    211     , fGrammarPoolMemoryManager(fGrammarResolver->getGrammarPoolMemoryManager())
    212     , fAnnotation(0)
    213     , fAttributeCheck(manager)
    214 {
    215     CleanupType cleanup(this, &TraverseSchema::cleanUp);
    216 
    217     try {
    218 
    219         if (fGrammarResolver && schemaRoot && fURIStringPool) {
    220 
    221             init();
    222 
    223             if (multipleImport)
    224             {
    225               // If we are working on an existing schema, do some
    226               // intitialization that is otherwise done by preprocessSchema.
    227               //
    228               fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry();
    229               fGroupRegistry = fSchemaGrammar->getGroupInfoRegistry();
    230               fAttGroupRegistry = fSchemaGrammar->getAttGroupInfoRegistry();
    231               fAttributeDeclRegistry = fSchemaGrammar->getAttributeDeclRegistry();
    232               fValidSubstitutionGroups = fSchemaGrammar->getValidSubstitutionGroups();
    233             }
    234 
    235             preprocessSchema(schemaRoot, schemaURL, multipleImport);
    236             doTraverseSchema(schemaRoot);
    237 
    238             // Store the scope and anon type counts in case we need to add
    239             // more to this grammar (multi-import case). schemaGrammar and
    240             // fSchemaGrammar should be the same here.
    241             //
    242             fSchemaGrammar->setScopeCount (fScopeCount);
    243             fSchemaGrammar->setAnonTypeCount (fAnonXSTypeCount);
    244         }
    245 
    246     }
    247     catch(const OutOfMemoryException&)
    248     {
    249         cleanup.release();
    250 
    251         throw;
    252     }
    253 
    254     cleanup.release();
     181                                                          , XMLStringPool* const
     182                                                          , SchemaGrammar* const   schemaGrammar
     183                                                          , GrammarResolver* const grammarResolver
     184                                                          , RefHash2KeysTableOf<SchemaInfo>* cachedSchemaInfoList
     185                                                          , RefHash2KeysTableOf<SchemaInfo>* schemaInfoList
     186                                                          , XMLScanner* const      xmlScanner
     187                                                          , const XMLCh* const     schemaURL
     188                                                          , XMLEntityHandler* const  entityHandler
     189                                                          , XMLErrorReporter* const errorReporter
     190                                                          , MemoryManager* const    manager
     191                                                          , bool multipleImport)
     192        : fFullConstraintChecking(false)
     193        , fTargetNSURI(-1)
     194        , fEmptyNamespaceURI(XMLNamespaceResolver::fEmptyUriId)
     195        , fCurrentScope(Grammar::TOP_LEVEL_SCOPE)
     196        , fScopeCount(schemaGrammar->getScopeCount ())
     197        , fAnonXSTypeCount(schemaGrammar->getAnonTypeCount ())
     198        , fCircularCheckIndex(0)
     199        , fTargetNSURIString(0)
     200        , fDatatypeRegistry(0)
     201        , fGrammarResolver(grammarResolver)
     202        , fSchemaGrammar(schemaGrammar)
     203        , fEntityHandler(entityHandler)
     204        , fErrorReporter(errorReporter)
     205        , fUriResolver(xmlScanner->getUriResolver())
     206        , fStringPool(0)
     207        , fBuffer(1023, manager)
     208        , fScanner(xmlScanner)
     209        , fAttributeDeclRegistry(0)
     210        , fComplexTypeRegistry(0)
     211        , fGroupRegistry(0)
     212        , fAttGroupRegistry(0)
     213        , fIC_ElementsNS(0)
     214        , fPreprocessedNodes(0)
     215        , fSchemaInfo(0)
     216        , fCurrentGroupInfo(0)
     217        , fCurrentAttGroupInfo(0)
     218        , fCurrentComplexType(0)
     219        , fCurrentTypeNameStack(0)
     220        , fCurrentGroupStack(0)
     221        , fIC_Elements(0)
     222        , fDeclStack(0)
     223        , fGlobalDeclarations(0)
     224        , fNonXSAttList(0)
     225        , fImportedNSList(0)
     226        , fIC_NodeListNS(0)
     227        , fNotationRegistry(0)
     228        , fRedefineComponents(0)
     229        , fIdentityConstraintNames(0)
     230        , fValidSubstitutionGroups(0)
     231        , fSchemaInfoList(schemaInfoList)
     232        , fCachedSchemaInfoList (cachedSchemaInfoList)
     233        , fParser(0)
     234        , fLocator(0)
     235        , fMemoryManager(manager)
     236        , fGrammarPoolMemoryManager(fGrammarResolver->getGrammarPoolMemoryManager())
     237        , fAnnotation(0)
     238        , fAttributeCheck(manager)
     239{
     240        CleanupType cleanup(this, &TraverseSchema::cleanUp);
     241
     242        try
     243        {
     244                if (fGrammarResolver && schemaRoot) // fUriResolver will never be NULL
     245                {
     246                        init();
     247
     248                        if (multipleImport)
     249                        {
     250                          // If we are working on an existing schema, do some
     251                          // intitialization that is otherwise done by preprocessSchema.
     252                          //
     253                          fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry();
     254                          fGroupRegistry = fSchemaGrammar->getGroupInfoRegistry();
     255                          fAttGroupRegistry = fSchemaGrammar->getAttGroupInfoRegistry();
     256                          fAttributeDeclRegistry = fSchemaGrammar->getAttributeDeclRegistry();
     257                          fValidSubstitutionGroups = fSchemaGrammar->getValidSubstitutionGroups();
     258                        }
     259
     260                        preprocessSchema(schemaRoot, schemaURL, multipleImport);
     261                        doTraverseSchema(schemaRoot);
     262
     263                        // Store the scope and anon type counts in case we need to add
     264                        // more to this grammar (multi-import case). schemaGrammar and
     265                        // fSchemaGrammar should be the same here.
     266                        //
     267                        fSchemaGrammar->setScopeCount (fScopeCount);
     268                        fSchemaGrammar->setAnonTypeCount (fAnonXSTypeCount);
     269                }
     270
     271        }
     272        catch(const OutOfMemoryException&)
     273        {
     274                cleanup.release();
     275
     276                throw;
     277        }
     278
     279        cleanup.release();
    255280}
    256281
     
    258283TraverseSchema::~TraverseSchema()
    259284{
    260    cleanUp();
     285        cleanUp();
    261286}
    262287
     
    265290//  TraverseSchema: Traversal methods
    266291// ---------------------------------------------------------------------------
    267 void TraverseSchema::doTraverseSchema(const DOMElement* const schemaRoot) {
    268 
    269     // process children nodes
    270     processChildren(schemaRoot);
    271 
    272     // Handle identity constraints - keyref
    273     if (fIC_ElementsNS && fIC_ElementsNS->containsKey(fTargetNSURIString)) {
    274 
    275         fIC_Elements = fIC_ElementsNS->get(fTargetNSURIString);
    276 
    277         XMLSize_t icListSize = fIC_Elements->size();
    278 
    279         for (XMLSize_t i=0; i < icListSize; i++) {
    280 
    281             SchemaElementDecl* curElem = fIC_Elements->elementAt(i);
    282             ValueVectorOf<DOMElement*>* icNodes =  fIC_NodeListNS->get(curElem);
    283             XMLSize_t icNodesSize = icNodes->size();
    284 
    285             for (XMLSize_t j = 0; j < icNodesSize; j++) {
    286                 traverseKeyRef(icNodes->elementAt(j), curElem);
    287             }
    288         }
    289     }
    290 
    291     if (fScanner->getValidateAnnotations() && !fSchemaGrammar->getAnnotations()->isEmpty())
    292     {
    293         validateAnnotations();
    294     }
    295     fSchemaInfo->setProcessed();
     292void TraverseSchema::doTraverseSchema(const DOMElement* const schemaRoot)
     293{
     294        DEBUG_SCHEMA_MESSAGE
     295        (
     296                "TraverseSchema::doTraverseSchema("
     297                << schemaRoot
     298                << ')'
     299        );
     300
     301        // process children nodes
     302        processChildren(schemaRoot);
     303
     304        // Handle identity constraints - keyref
     305        if (fIC_ElementsNS && fIC_ElementsNS->containsKey(fTargetNSURIString))
     306        {
     307                fIC_Elements = fIC_ElementsNS->get(fTargetNSURIString);
     308                XMLSize_t icListSize = fIC_Elements->size();
     309
     310                for (XMLSize_t i = 0; i < icListSize; i++)
     311                {
     312                        SchemaElementDecl* curElem = fIC_Elements->elementAt(i);
     313                        ValueVectorOf<DOMElement*>* icNodes =  fIC_NodeListNS->get(curElem);
     314                        XMLSize_t icNodesSize = icNodes->size();
     315                        for (XMLSize_t j = 0; j < icNodesSize; j++)
     316                        {
     317                                traverseKeyRef(icNodes->elementAt(j), curElem);
     318                        }
     319                }
     320        }
     321
     322
     323
     324        if (fScanner->getValidateAnnotations() && !fSchemaGrammar->getAnnotations()->isEmpty())
     325        {
     326                validateAnnotations();
     327        }
     328        fSchemaInfo->setProcessed();
    296329}
    297330
    298331void TraverseSchema::preprocessSchema(DOMElement* const schemaRoot,
    299                                       const XMLCh* const schemaURL,
    300                                       bool  multipleImport) {
    301     if (!multipleImport) {
    302         // Make sure namespace binding is defaulted
    303         const XMLCh* rootPrefix = schemaRoot->getPrefix();
    304 
    305         if (rootPrefix == 0 || !*rootPrefix) {
    306 
    307             const XMLCh* xmlnsStr = schemaRoot->getAttribute(XMLUni::fgXMLNSString);
    308 
    309             if (!xmlnsStr || !*xmlnsStr) {
    310                 schemaRoot->setAttribute(XMLUni::fgXMLNSString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
    311             }
    312         }
    313 
    314         // Set schemaGrammar data and add it to GrammarResolver
    315         // For complex type registry, attribute decl registry , group/attGroup
    316         // and namespace mapping, needs to check whether the passed in
    317         // Grammar was a newly instantiated one.
    318         fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry();
    319 
    320         if (fComplexTypeRegistry == 0 ) {
    321 
    322             fComplexTypeRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<ComplexTypeInfo>(29, fGrammarPoolMemoryManager);
    323             fSchemaGrammar->setComplexTypeRegistry(fComplexTypeRegistry);
    324         }
    325 
    326         fGroupRegistry = fSchemaGrammar->getGroupInfoRegistry();
    327 
    328         if (fGroupRegistry == 0 ) {
    329 
    330             fGroupRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XercesGroupInfo>(13, fGrammarPoolMemoryManager);
    331             fSchemaGrammar->setGroupInfoRegistry(fGroupRegistry);
    332         }
    333 
    334         fAttGroupRegistry = fSchemaGrammar->getAttGroupInfoRegistry();
    335 
    336         if (fAttGroupRegistry == 0 ) {
    337 
    338             fAttGroupRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XercesAttGroupInfo>(13, fGrammarPoolMemoryManager);
    339             fSchemaGrammar->setAttGroupInfoRegistry(fAttGroupRegistry);
    340         }
    341 
    342         fAttributeDeclRegistry = fSchemaGrammar->getAttributeDeclRegistry();
    343 
    344         if (fAttributeDeclRegistry == 0) {
    345 
    346             fAttributeDeclRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XMLAttDef>(29, fGrammarPoolMemoryManager);
    347             fSchemaGrammar->setAttributeDeclRegistry(fAttributeDeclRegistry);
    348         }
    349 
    350         fValidSubstitutionGroups = fSchemaGrammar->getValidSubstitutionGroups();
    351 
    352         if (!fValidSubstitutionGroups) {
    353 
    354             fValidSubstitutionGroups = new (fGrammarPoolMemoryManager) RefHash2KeysTableOf<ElemVector>(29, fGrammarPoolMemoryManager);
    355             fSchemaGrammar->setValidSubstitutionGroups(fValidSubstitutionGroups);
    356         }
    357 
    358         //Retrieve the targetnamespace URI information
    359         const XMLCh* targetNSURIStr = schemaRoot->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE);
    360         fSchemaGrammar->setTargetNamespace(targetNSURIStr);
    361 
    362         fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
    363         fTargetNSURIString = fSchemaGrammar->getTargetNamespace();
    364         fTargetNSURI = fURIStringPool->addOrFind(fTargetNSURIString);
    365 
    366         XMLSchemaDescription* gramDesc = (XMLSchemaDescription*) fSchemaGrammar->getGrammarDescription();
    367         gramDesc->setTargetNamespace(fTargetNSURIString);
    368 
    369         fGrammarResolver->putGrammar(fSchemaGrammar);
    370     }
    371     else {
    372         fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
    373 
    374         fTargetNSURIString = fSchemaGrammar->getTargetNamespace();
    375         fTargetNSURI = fURIStringPool->addOrFind(fTargetNSURIString);
    376     }
    377 
    378     SchemaInfo* currInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI,
    379                                           fSchemaInfo?fSchemaInfo->getNamespaceScope():NULL,
    380                                           schemaURL,
    381                                           fTargetNSURIString, schemaRoot,
    382                                           fScanner,
    383                                           fGrammarPoolMemoryManager);
    384 
    385     if (fSchemaInfo)
    386         fSchemaInfo->addSchemaInfo(currInfo, SchemaInfo::IMPORT);
    387     else
    388     {
    389         currInfo->getNamespaceScope()->reset(fEmptyNamespaceURI);
    390         // Add mapping for the xml prefix
    391         currInfo->getNamespaceScope()->addPrefix(XMLUni::fgXMLString, fURIStringPool->addOrFind(XMLUni::fgXMLURIName));
    392     }
    393     addImportedNS(currInfo->getTargetNSURI());
    394 
    395     fSchemaInfo = currInfo;
    396     fSchemaInfoList->put((void*) fSchemaInfo->getCurrentSchemaURL(), fSchemaInfo->getTargetNSURI(), fSchemaInfo);
    397     fSchemaInfo->addSchemaInfo(fSchemaInfo, SchemaInfo::INCLUDE);
    398     traverseSchemaHeader(schemaRoot);
    399 
    400     // preprocess chidren
    401     preprocessChildren(schemaRoot);
     332                                                                          const XMLCh* const schemaURL,
     333                                                                          bool  multipleImport)
     334{
     335        DEBUG_SCHEMA_MESSAGE
     336        (
     337                "TraverseSchema::preprocessSchema("
     338                << schemaRoot
     339                << ',' << schemaURL
     340                << ',' << multipleImport
     341                << ')'
     342        );
     343
     344        if (!multipleImport)
     345        {
     346                // Make sure namespace binding is defaulted
     347                const XMLCh* rootPrefix = schemaRoot->getPrefix();
     348
     349                if (rootPrefix == 0 || !*rootPrefix)
     350                {
     351                        const XMLCh* xmlnsStr = schemaRoot->getAttribute(XMLUni::fgXMLNSString);
     352                        if (!xmlnsStr || !*xmlnsStr)
     353                        {
     354                                schemaRoot->setAttribute(XMLUni::fgXMLNSString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
     355                        }
     356                }
     357
     358                // Set schemaGrammar data and add it to GrammarResolver
     359                // For complex type registry, attribute decl registry , group/attGroup
     360                // and namespace mapping, needs to check whether the passed in
     361                // Grammar was a newly instantiated one.
     362                fComplexTypeRegistry = fSchemaGrammar->getComplexTypeRegistry();
     363
     364                if (fComplexTypeRegistry == 0 )
     365                {
     366                        fComplexTypeRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<ComplexTypeInfo>(29, fGrammarPoolMemoryManager);
     367                        fSchemaGrammar->setComplexTypeRegistry(fComplexTypeRegistry);
     368                }
     369
     370                fGroupRegistry = fSchemaGrammar->getGroupInfoRegistry();
     371
     372                if (fGroupRegistry == 0 )
     373                {
     374                        fGroupRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XercesGroupInfo>(13, fGrammarPoolMemoryManager);
     375                        fSchemaGrammar->setGroupInfoRegistry(fGroupRegistry);
     376                }
     377
     378                fAttGroupRegistry = fSchemaGrammar->getAttGroupInfoRegistry();
     379
     380                if (fAttGroupRegistry == 0 )
     381                {
     382                        fAttGroupRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XercesAttGroupInfo>(13, fGrammarPoolMemoryManager);
     383                        fSchemaGrammar->setAttGroupInfoRegistry(fAttGroupRegistry);
     384                }
     385
     386                fAttributeDeclRegistry = fSchemaGrammar->getAttributeDeclRegistry();
     387
     388                if (fAttributeDeclRegistry == 0)
     389                {
     390                        fAttributeDeclRegistry = new (fGrammarPoolMemoryManager) RefHashTableOf<XMLAttDef>(29, fGrammarPoolMemoryManager);
     391                        fSchemaGrammar->setAttributeDeclRegistry(fAttributeDeclRegistry);
     392                }
     393
     394                fValidSubstitutionGroups = fSchemaGrammar->getValidSubstitutionGroups();
     395
     396                if (!fValidSubstitutionGroups)
     397                {
     398                        fValidSubstitutionGroups = new (fGrammarPoolMemoryManager) RefHash2KeysTableOf<ElemVector>(29, fGrammarPoolMemoryManager);
     399                        fSchemaGrammar->setValidSubstitutionGroups(fValidSubstitutionGroups);
     400                }
     401
     402                //Retrieve the targetnamespace URI information
     403                const XMLCh* targetNSURIStr = schemaRoot->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE);
     404                fSchemaGrammar->setTargetNamespace(targetNSURIStr);
     405
     406                fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
     407                fTargetNSURIString = fSchemaGrammar->getTargetNamespace();
     408
     409                XMLSchemaDescription* gramDesc = (XMLSchemaDescription*) fSchemaGrammar->getGrammarDescription();
     410                gramDesc->setTargetNamespace(fTargetNSURIString);
     411
     412                fGrammarResolver->putGrammar(fSchemaGrammar);
     413        }
     414        else
     415        {
     416                fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
     417                fTargetNSURIString = fSchemaGrammar->getTargetNamespace();
     418        }
     419
     420        fTargetNSURI = RESOLVE_URI_ID(fTargetNSURIString);
     421
     422        DEBUG_SCHEMA_MESSAGE(fTargetNSURIString << "->" << fUriResolver->getUriForId(fTargetNSURI));
     423
     424        SchemaInfo* currInfo =
     425                new (fMemoryManager) SchemaInfo
     426                (
     427                        0, 0, 0, fTargetNSURI,
     428                        NULL, // fSchemaInfo ? fSchemaInfo->getNamespaceScope() : NULL,
     429                        schemaURL,
     430                        fTargetNSURIString, schemaRoot,
     431                        fScanner,
     432                        fGrammarPoolMemoryManager
     433                );
     434
     435//      if (fSchemaInfo)
     436//      {
     437//              fSchemaInfo->addSchemaInfo(currInfo, SchemaInfo::IMPORT);
     438//      }
     439//      else
     440//      {
     441                currInfo->getNamespaceScope()->reset(fEmptyNamespaceURI);
     442                // Add mapping for the xml prefix
     443                currInfo->getNamespaceScope()->addPrefix
     444                (
     445                        XMLUni::fgXMLString
     446                        , XMLNamespaceResolver::fXMLUriId
     447                );
     448//      }
     449
     450        if (fSchemaInfo)
     451        {
     452                fSchemaInfo->addSchemaInfo(currInfo, SchemaInfo::IMPORT);
     453        }
     454
     455        addImportedNS(currInfo->getTargetNSURI());
     456
     457        fSchemaInfo = currInfo;
     458
     459        fSchemaInfoList->put((void*) fSchemaInfo->getCurrentSchemaURL(), fSchemaInfo->getTargetNSURI(), fSchemaInfo);
     460
     461
     462        fSchemaInfo->addSchemaInfo(fSchemaInfo, SchemaInfo::INCLUDE);
     463        traverseSchemaHeader(schemaRoot);
     464
     465        // preprocess chidren
     466        preprocessChildren(schemaRoot);
    402467}
    403468
    404469
    405 void TraverseSchema::traverseSchemaHeader(const DOMElement* const schemaRoot) {
    406 
    407     // Make sure that the root element is <xsd:schema>
    408     if (!XMLString::equals(schemaRoot->getLocalName(), SchemaSymbols::fgELT_SCHEMA)) {
    409         reportSchemaError(schemaRoot, XMLUni::fgXMLErrDomain, XMLErrs::InvalidXMLSchemaRoot);
    410     }
    411 
    412     // Make sure that the targetNamespace value is not empty string
    413     checkForEmptyTargetNamespace(schemaRoot);
    414 
    415     // -----------------------------------------------------------------------
    416     // Check Attributes
    417     // -----------------------------------------------------------------------
    418     fAttributeCheck.checkAttributes(
    419         schemaRoot, GeneralAttributeCheck::E_Schema, this
    420         , true, fSchemaInfo->getNonXSAttList()
    421     );
    422 
    423     retrieveNamespaceMapping(schemaRoot);
    424     // Add mapping for the default namespace
    425     if ((!fTargetNSURIString || !*fTargetNSURIString) && schemaRoot->getAttributeNode(XMLUni::fgXMLNSString)==NULL)
    426         fSchemaInfo->getNamespaceScope()->addPrefix(XMLUni::fgZeroLenString, fEmptyNamespaceURI);
    427 
    428     unsigned short elemAttrDefaultQualified = 0;
    429 
    430     if (XMLString::equals(schemaRoot->getAttribute(SchemaSymbols::fgATT_ELEMENTFORMDEFAULT),
    431                                   SchemaSymbols::fgATTVAL_QUALIFIED)) {
    432         elemAttrDefaultQualified |= Elem_Def_Qualified;
    433     }
    434 
    435     if (XMLString::equals(schemaRoot->getAttribute(SchemaSymbols::fgATT_ATTRIBUTEFORMDEFAULT),
    436                                   SchemaSymbols::fgATTVAL_QUALIFIED)) {
    437         elemAttrDefaultQualified |= Attr_Def_Qualified;
    438     }
    439 
    440     fSchemaInfo->setElemAttrDefaultQualified(elemAttrDefaultQualified);
    441     fSchemaInfo->setBlockDefault(parseBlockSet(schemaRoot, ES_Block, true));
    442     fSchemaInfo->setFinalDefault(parseFinalSet(schemaRoot, ECS_Final, true));
     470void TraverseSchema::traverseSchemaHeader(const DOMElement* const schemaRoot)
     471{
     472        DEBUG_SCHEMA_MESSAGE
     473        (
     474                "TraverseSchema::traverseSchemaHeader(" << schemaRoot << ')'
     475        );
     476
     477        // Make sure that the root element is <xsd:schema>
     478        if (!XMLString::equals(schemaRoot->getLocalName(), SchemaSymbols::fgELT_SCHEMA))
     479        {
     480                reportSchemaError(schemaRoot, XMLUni::fgXMLErrDomain, XMLErrs::InvalidXMLSchemaRoot);
     481        }
     482
     483        // Make sure that the targetNamespace value is not empty string
     484        checkForEmptyTargetNamespace(schemaRoot);
     485
     486        // -----------------------------------------------------------------------
     487        // Check Attributes
     488        // -----------------------------------------------------------------------
     489        fAttributeCheck.checkAttributes
     490        (
     491                schemaRoot, GeneralAttributeCheck::E_Schema, this
     492                , true, fSchemaInfo->getNonXSAttList()
     493        );
     494
     495        retrieveNamespaceMapping(schemaRoot);
     496
     497        DEBUG_SCHEMA_MESSAGE
     498        (
     499                "fTargetNSURIString=" << fTargetNSURIString
     500        );
     501
     502        // Add mapping for the default namespace
     503        if ((!fTargetNSURIString || !*fTargetNSURIString) && schemaRoot->getAttributeNode(XMLUni::fgXMLNSString)==NULL)
     504        {
     505                fSchemaInfo->getNamespaceScope()->addPrefix(XMLUni::fgZeroLenString, fEmptyNamespaceURI);
     506        }
     507
     508        unsigned short elemAttrDefaultQualified = 0;
     509
     510        if (XMLString::equals(schemaRoot->getAttribute(SchemaSymbols::fgATT_ELEMENTFORMDEFAULT),
     511                                                                  SchemaSymbols::fgATTVAL_QUALIFIED))
     512        {
     513                elemAttrDefaultQualified |= Elem_Def_Qualified;
     514        }
     515
     516        if (XMLString::equals(schemaRoot->getAttribute(SchemaSymbols::fgATT_ATTRIBUTEFORMDEFAULT),
     517                                                                  SchemaSymbols::fgATTVAL_QUALIFIED))
     518        {
     519                elemAttrDefaultQualified |= Attr_Def_Qualified;
     520        }
     521
     522        fSchemaInfo->setElemAttrDefaultQualified(elemAttrDefaultQualified);
     523        fSchemaInfo->setBlockDefault(parseBlockSet(schemaRoot, ES_Block, true));
     524        fSchemaInfo->setFinalDefault(parseFinalSet(schemaRoot, ECS_Final, true));
    443525}
    444526
     
    446528XSAnnotation*
    447529TraverseSchema::traverseAnnotationDecl(const DOMElement* const annotationElem,
    448                                        ValueVectorOf<DOMNode*>* const nonXSAttList,
    449                                        const bool topLevel) {
    450 
    451     NamespaceScopeManager nsMgr(annotationElem, fSchemaInfo, this);
    452     // -----------------------------------------------------------------------
    453     // Check Attributes
    454     // -----------------------------------------------------------------------
    455     fAttributeCheck.checkAttributes(
    456         annotationElem, GeneralAttributeCheck::E_Annotation, this, topLevel
    457     );
    458 
    459     const XMLCh* contents = 0;
    460     DOMElement* child = XUtil::getFirstChildElement(annotationElem);
    461     if (child) {
    462         for (;
    463              child != 0;
    464              child = XUtil::getNextSiblingElement(child)) {
    465 
    466             const XMLCh* name = child->getLocalName();
    467 
    468             if (XMLString::equals(name, SchemaSymbols::fgELT_APPINFO)) {
    469 
    470                 DOMNode* textContent = child->getFirstChild();
    471                 if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE)
    472                     contents = ((DOMText*) textContent)->getData();
    473 
    474                 fAttributeCheck.checkAttributes(child, GeneralAttributeCheck::E_Appinfo, this);
    475             }
    476             else if (XMLString::equals(name, SchemaSymbols::fgELT_DOCUMENTATION)) {
    477 
    478                 DOMNode* textContent = child->getFirstChild();
    479                 if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE)
    480                     contents = ((DOMText*) textContent)->getData();
    481 
    482                 fAttributeCheck.checkAttributes(child, GeneralAttributeCheck::E_Documentation, this);
    483             }
    484             else {
    485                 reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAnnotationContent);
    486             }
    487         }
    488     }
    489     else
    490     {
    491         // If the Annotation has no children, get the text directly
    492         DOMNode* textContent = annotationElem->getFirstChild();
    493         if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE)
    494             contents = ((DOMText*) textContent)->getData();
    495     }
    496 
    497     if (contents && !fScanner->getIgnoreAnnotations())
    498     {
    499         XSAnnotation* theAnnotation = 0;
    500 
    501         XMLSize_t nonXSAttSize = nonXSAttList->size();
    502 
    503         if (nonXSAttSize)
    504         {
    505             int annotTokenStart = XMLString::patternMatch(
    506                 contents, SchemaSymbols::fgELT_ANNOTATION);
    507 
    508             if (annotTokenStart == -1) // something is wrong
    509                 return 0;
    510 
    511             // set annotation element
    512             fBuffer.set(contents, annotTokenStart + 10);
    513 
    514             for (XMLSize_t i=0; i<nonXSAttSize; i++)
    515             {
    516                 DOMNode* attNode = nonXSAttList->elementAt(i);
    517 
    518                 if (!XMLString::equals(
    519                         annotationElem->getAttributeNS(
    520                            attNode->getNamespaceURI(), attNode->getLocalName())
    521                         , XMLUni::fgZeroLenString)
    522                    )
    523                 {
    524                     continue;
    525                 }
    526 
    527                 fBuffer.append(chSpace);
    528                 fBuffer.append(attNode->getNodeName());
    529                 fBuffer.append(chEqual);
    530                 fBuffer.append(chDoubleQuote);
    531                 processAttValue(attNode->getNodeValue(), fBuffer);
    532                 fBuffer.append(chDoubleQuote);
    533             }
    534 
    535             // add remaining annotation content
    536             fBuffer.append(contents + annotTokenStart + 10);
    537 
    538             theAnnotation = new (fGrammarPoolMemoryManager) XSAnnotation(fBuffer.getRawBuffer(), fGrammarPoolMemoryManager);
    539         }
    540         else
    541         {
    542             theAnnotation = new (fGrammarPoolMemoryManager) XSAnnotation(contents, fGrammarPoolMemoryManager);
    543         }
    544 
    545         /***
    546          * set line, col and systemId info
    547         ***/
    548         theAnnotation->setLineCol(
    549                                   ((XSDElementNSImpl*)annotationElem)->getLineNo()
    550                                 , ((XSDElementNSImpl*)annotationElem)->getColumnNo()
    551                                  );
    552         theAnnotation->setSystemId(fSchemaInfo->getCurrentSchemaURL());
    553 
    554         return theAnnotation;
    555     }
    556 
    557     return 0;
     530                                                                           ValueVectorOf<DOMNode*>* const nonXSAttList,
     531                                                                           const bool topLevel)
     532{
     533        DEBUG_SCHEMA_MESSAGE
     534        (
     535                "TraverseSchema::traverseSchemaHeader(" << annotationElem << ',' << nonXSAttList << ',' << topLevel << ')'
     536        );
     537
     538        NamespaceScopeManager nsMgr(annotationElem, fSchemaInfo, this);
     539        // -----------------------------------------------------------------------
     540        // Check Attributes
     541        // -----------------------------------------------------------------------
     542        fAttributeCheck.checkAttributes
     543        (
     544                annotationElem, GeneralAttributeCheck::E_Annotation, this, topLevel
     545        );
     546
     547        const XMLCh* contents = 0;
     548        DOMElement* child = XUtil::getFirstChildElement(annotationElem);
     549        if (child)
     550        {
     551                do
     552                {
     553                        const XMLCh* name = child->getLocalName();
     554                        if (XMLString::equals(name, SchemaSymbols::fgELT_APPINFO))
     555                        {
     556                                DOMNode* textContent = child->getFirstChild();
     557                                if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE)
     558                                        contents = ((DOMText*) textContent)->getData();
     559
     560                                fAttributeCheck.checkAttributes(child, GeneralAttributeCheck::E_Appinfo, this);
     561                        }
     562                        else if (XMLString::equals(name, SchemaSymbols::fgELT_DOCUMENTATION))
     563                        {
     564                                DOMNode* textContent = child->getFirstChild();
     565                                if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE)
     566                                        contents = ((DOMText*) textContent)->getData();
     567
     568                                fAttributeCheck.checkAttributes(child, GeneralAttributeCheck::E_Documentation, this);
     569                        }
     570                        else
     571                        {
     572                                reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAnnotationContent);
     573                        }
     574                }
     575                while ((child = XUtil::getNextSiblingElement(child)) != NULL);
     576        }
     577        else
     578        {
     579                // If the Annotation has no children, get the text directly
     580                DOMNode* textContent = annotationElem->getFirstChild();
     581                if (textContent && textContent->getNodeType() == DOMNode::TEXT_NODE)
     582                        contents = ((DOMText*) textContent)->getData();
     583        }
     584
     585        if (contents && !fScanner->getIgnoreAnnotations())
     586        {
     587                XSAnnotation* theAnnotation = 0;
     588
     589                XMLSize_t nonXSAttSize = nonXSAttList->size();
     590
     591                if (nonXSAttSize)
     592                {
     593                        int annotTokenStart = XMLString::patternMatch(
     594                                contents, SchemaSymbols::fgELT_ANNOTATION);
     595
     596                        if (annotTokenStart == -1) // something is wrong
     597                        {
     598                                return 0;
     599                        }
     600
     601                        // set annotation element
     602                        fBuffer.set(contents, annotTokenStart + 10);
     603
     604                        for (XMLSize_t i=0; i<nonXSAttSize; i++)
     605                        {
     606                                DOMNode* attNode = nonXSAttList->elementAt(i);
     607
     608                                if (!XMLString::equals(
     609                                                annotationElem->getAttributeNS(
     610                                                   attNode->getNamespaceURI(), attNode->getLocalName())
     611                                                , XMLUni::fgZeroLenString)
     612                                   )
     613                                {
     614                                        continue;
     615                                }
     616
     617                                fBuffer.append(chSpace);
     618                                fBuffer.append(attNode->getNodeName());
     619                                fBuffer.append(chEqual);
     620                                fBuffer.append(chDoubleQuote);
     621                                processAttValue(attNode->getNodeValue(), fBuffer);
     622                                fBuffer.append(chDoubleQuote);
     623                        }
     624
     625                        // add remaining annotation content
     626                        fBuffer.append(contents + annotTokenStart + 10);
     627
     628                        theAnnotation = new (fGrammarPoolMemoryManager) XSAnnotation(fBuffer.getRawBuffer(), fGrammarPoolMemoryManager);
     629                }
     630                else
     631                {
     632                        theAnnotation = new (fGrammarPoolMemoryManager) XSAnnotation(contents, fGrammarPoolMemoryManager);
     633                }
     634
     635                /***
     636                 * set line, col and systemId info
     637                ***/
     638                theAnnotation->setLineCol(
     639                                                                  ((XSDElementNSImpl*)annotationElem)->getLineNo()
     640                                                                , ((XSDElementNSImpl*)annotationElem)->getColumnNo()
     641                                                                 );
     642                theAnnotation->setSystemId(fSchemaInfo->getCurrentSchemaURL());
     643
     644                return theAnnotation;
     645        }
     646
     647        return 0;
    558648}
    559649
     
    569659  *    </include>
    570660  */
    571 void TraverseSchema::preprocessInclude(const DOMElement* const elem) {
    572 
    573     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    574 
    575     // -----------------------------------------------------------------------
    576     // Check attributes
    577     // -----------------------------------------------------------------------
    578     fAttributeCheck.checkAttributes(
    579         elem, GeneralAttributeCheck::E_Include, this, true, fNonXSAttList);
    580 
    581     // -----------------------------------------------------------------------
    582     // First, handle any ANNOTATION declaration
    583     // -----------------------------------------------------------------------
    584     if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0)
    585         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected);
    586 
    587     if (fAnnotation)
    588         fSchemaGrammar->addAnnotation(fAnnotation);
    589     else if (fScanner->getGenerateSyntheticAnnotations() && fNonXSAttList->size())
    590     {
    591         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    592         fSchemaGrammar->addAnnotation(fAnnotation);
    593     }
    594 
    595     // -----------------------------------------------------------------------
    596     // Get 'schemaLocation' attribute
    597     // -----------------------------------------------------------------------
    598     const XMLCh* schemaLocation = getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION, DatatypeValidator::AnyURI);
    599 
    600     if (!schemaLocation || !*schemaLocation) {
    601         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNoSchemaLocation, SchemaSymbols::fgELT_INCLUDE);
    602         return;
    603     }
    604 
    605     // ------------------------------------------------------------------
    606     // Resolve schema location
    607     // ------------------------------------------------------------------
    608     fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0,
    609                         ((XSDElementNSImpl*) elem)->getLineNo(),
    610                         ((XSDElementNSImpl*) elem)->getColumnNo());
    611     InputSource* srcToFill = resolveSchemaLocation(schemaLocation,
    612             XMLResourceIdentifier::SchemaInclude);
    613     Janitor<InputSource> janSrc(srcToFill);
    614 
    615     // Nothing to do
    616     if (!srcToFill) {
    617         return;
    618     }
    619 
    620     const XMLCh* includeURL = srcToFill->getSystemId();
    621     SchemaInfo* includeSchemaInfo = fCachedSchemaInfoList->get(includeURL, fTargetNSURI);
    622 
    623     if (!includeSchemaInfo && fSchemaInfoList != fCachedSchemaInfoList)
    624       includeSchemaInfo = fSchemaInfoList->get(includeURL, fTargetNSURI);
    625 
    626     if (includeSchemaInfo) {
    627 
    628         fSchemaInfo->addSchemaInfo(includeSchemaInfo, SchemaInfo::INCLUDE);
    629         return;
    630     }
    631 
    632     // ------------------------------------------------------------------
    633     // Parse input source
    634     // ------------------------------------------------------------------
    635     if (!fParser)
    636         fParser = new (fGrammarPoolMemoryManager) XSDDOMParser(0, fGrammarPoolMemoryManager, 0);
    637 
    638     fParser->setValidationScheme(XercesDOMParser::Val_Never);
    639     fParser->setDoNamespaces(true);
    640     fParser->setUserEntityHandler(fEntityHandler);
    641     fParser->setUserErrorReporter(fErrorReporter);
    642 
    643     // Should just issue warning if the schema is not found
    644     bool flag = srcToFill->getIssueFatalErrorIfNotFound();
    645     srcToFill->setIssueFatalErrorIfNotFound(false);
    646 
    647     fParser->parse(*srcToFill);
    648 
    649     // Reset the InputSource
    650     srcToFill->setIssueFatalErrorIfNotFound(flag);
    651 
    652     if (fParser->getSawFatal() && fScanner->getExitOnFirstFatal())
    653         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::SchemaScanFatalError);
    654 
    655     // ------------------------------------------------------------------
    656     // Get root element
    657     // ------------------------------------------------------------------
    658     DOMDocument* document = fParser->getDocument();
    659 
    660     if (document) {
    661 
    662         DOMElement* root = document->getDocumentElement();
    663 
    664         if (root) {
    665 
    666             const XMLCh* targetNSURIString = root->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE);
    667 
    668             // check to see if targetNameSpace is right
    669             if (*targetNSURIString
    670                 && !XMLString::equals(targetNSURIString,fTargetNSURIString)){
    671                 reportSchemaError(root, XMLUni::fgXMLErrDomain, XMLErrs::IncludeNamespaceDifference,
    672                                   schemaLocation, targetNSURIString);
    673                 return;
    674             }
    675 
    676             // if targetNamespace is empty, change it to includ'g schema
    677             // targetNamespace
    678             if (!*targetNSURIString && root->getAttributeNode(XMLUni::fgXMLNSString) == 0
    679                 && fTargetNSURI != fEmptyNamespaceURI) {
    680                 root->setAttribute(XMLUni::fgXMLNSString, fTargetNSURIString);
    681             }
    682 
    683             // --------------------------------------------------------
    684             // Update schema information with included schema
    685             // --------------------------------------------------------
    686             SchemaInfo* saveInfo = fSchemaInfo;
    687 
    688             fSchemaInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI,
    689                                          fSchemaInfo->getNamespaceScope(),
    690                                          includeURL,
    691                                          fTargetNSURIString, root,
    692                                          fScanner,
    693                                          fGrammarPoolMemoryManager);
    694 
    695             fSchemaInfoList->put((void*) fSchemaInfo->getCurrentSchemaURL(),
    696                                  fSchemaInfo->getTargetNSURI(), fSchemaInfo);
    697             fPreprocessedNodes->put((void*) elem, fSchemaInfo);
    698             saveInfo->addSchemaInfo(fSchemaInfo, SchemaInfo::INCLUDE);
    699             traverseSchemaHeader(root);
    700             preprocessChildren(root);
    701             fSchemaInfo = saveInfo;
    702         }
    703     }
     661void TraverseSchema::preprocessInclude(const DOMElement* const elem)
     662{
     663        DEBUG_SCHEMA_MESSAGE
     664        (
     665                "TraverseSchema::preprocessInclude("
     666                << elem
     667                << ')'
     668        );
     669
     670        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     671
     672        // -----------------------------------------------------------------------
     673        // Check attributes
     674        // -----------------------------------------------------------------------
     675        fAttributeCheck.checkAttributes(
     676                elem, GeneralAttributeCheck::E_Include, this, true, fNonXSAttList);
     677
     678        // -----------------------------------------------------------------------
     679        // First, handle any ANNOTATION declaration
     680        // -----------------------------------------------------------------------
     681        if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0)
     682                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected);
     683
     684        if (fAnnotation)
     685                fSchemaGrammar->addAnnotation(fAnnotation);
     686        else if (fScanner->getGenerateSyntheticAnnotations() && fNonXSAttList->size())
     687        {
     688                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     689                fSchemaGrammar->addAnnotation(fAnnotation);
     690        }
     691
     692        // -----------------------------------------------------------------------
     693        // Get 'schemaLocation' attribute
     694        // -----------------------------------------------------------------------
     695        const XMLCh* schemaLocation = getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION, DatatypeValidator::AnyURI);
     696
     697        if (!schemaLocation || !*schemaLocation)
     698        {
     699                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNoSchemaLocation, SchemaSymbols::fgELT_INCLUDE);
     700                return;
     701        }
     702
     703        // ------------------------------------------------------------------
     704        // Resolve schema location
     705        // ------------------------------------------------------------------
     706        fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0,
     707                                                ((XSDElementNSImpl*) elem)->getLineNo(),
     708                                                ((XSDElementNSImpl*) elem)->getColumnNo());
     709        InputSource* srcToFill = resolveSchemaLocation(schemaLocation,
     710                        XMLResourceIdentifier::SchemaInclude);
     711        Janitor<InputSource> janSrc(srcToFill);
     712
     713        // Nothing to do
     714        if (!srcToFill) {
     715                return;
     716        }
     717
     718        const XMLCh* includeURL = srcToFill->getSystemId();
     719        SchemaInfo* includeSchemaInfo = fCachedSchemaInfoList->get(includeURL, fTargetNSURI);
     720
     721        if (!includeSchemaInfo && fSchemaInfoList != fCachedSchemaInfoList)
     722          includeSchemaInfo = fSchemaInfoList->get(includeURL, fTargetNSURI);
     723
     724        if (includeSchemaInfo) {
     725
     726                fSchemaInfo->addSchemaInfo(includeSchemaInfo, SchemaInfo::INCLUDE);
     727                return;
     728        }
     729
     730        // ------------------------------------------------------------------
     731        // Parse input source
     732        // ------------------------------------------------------------------
     733        if (!fParser)
     734                fParser = new (fGrammarPoolMemoryManager) XSDDOMParser(0, fGrammarPoolMemoryManager, 0);
     735
     736        fParser->setValidationScheme(XercesDOMParser::Val_Never);
     737        fParser->getScanner()->setUriResolver(fUriResolver);
     738        fParser->setDoNamespaces(true);
     739        fParser->setUserEntityHandler(fEntityHandler);
     740        fParser->setUserErrorReporter(fErrorReporter);
     741
     742        // Should just issue warning if the schema is not found
     743        bool flag = srcToFill->getIssueFatalErrorIfNotFound();
     744        srcToFill->setIssueFatalErrorIfNotFound(false);
     745
     746        fParser->parse(*srcToFill);
     747
     748        // Reset the InputSource
     749        srcToFill->setIssueFatalErrorIfNotFound(flag);
     750
     751        if (fParser->getSawFatal() && fScanner->getExitOnFirstFatal())
     752                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::SchemaScanFatalError);
     753
     754        // ------------------------------------------------------------------
     755        // Get root element
     756        // ------------------------------------------------------------------
     757        DOMDocument* document = fParser->getDocument();
     758
     759        if (document)
     760        {
     761                DOMElement* root = document->getDocumentElement();
     762                if (root)
     763                {
     764
     765                        const XMLCh* targetNSURIString = root->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE);
     766
     767                        // check to see if targetNameSpace is right
     768                        if (*targetNSURIString && !XMLString::equals(targetNSURIString,fTargetNSURIString))
     769                        {
     770                                reportSchemaError(root, XMLUni::fgXMLErrDomain, XMLErrs::IncludeNamespaceDifference,
     771                                                                  schemaLocation, targetNSURIString);
     772                                return;
     773                        }
     774
     775                        // if targetNamespace is empty, change it to includ'g schema
     776                        // targetNamespace
     777                        if (!*targetNSURIString && root->getAttributeNode(XMLUni::fgXMLNSString) == 0
     778                                && fTargetNSURI != fEmptyNamespaceURI) {
     779                                root->setAttribute(XMLUni::fgXMLNSString, fTargetNSURIString);
     780                        }
     781
     782                        // --------------------------------------------------------
     783                        // Update schema information with included schema
     784                        // --------------------------------------------------------
     785                        SchemaInfo* saveInfo = fSchemaInfo;
     786
     787                        fSchemaInfo = new (fMemoryManager) SchemaInfo(0, 0, 0, fTargetNSURI,
     788                                                                                 fSchemaInfo->getNamespaceScope(),
     789                                                                                 includeURL,
     790                                                                                 fTargetNSURIString, root,
     791                                                                                 fScanner,
     792                                                                                 fGrammarPoolMemoryManager);
     793
     794                        fSchemaInfoList->put((void*) fSchemaInfo->getCurrentSchemaURL(),
     795                                                                 fSchemaInfo->getTargetNSURI(), fSchemaInfo);
     796                        fPreprocessedNodes->put((void*) elem, fSchemaInfo);
     797                        saveInfo->addSchemaInfo(fSchemaInfo, SchemaInfo::INCLUDE);
     798                        traverseSchemaHeader(root);
     799                        preprocessChildren(root);
     800                        fSchemaInfo = saveInfo;
     801                }
     802        }
    704803}
    705804
    706805
    707 void TraverseSchema::traverseInclude(const DOMElement* const elem) {
    708 
    709     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    710 
    711     SchemaInfo* includeInfo = fPreprocessedNodes->get(elem);
    712 
    713     if (includeInfo) {
    714 
    715         SchemaInfo* saveInfo = fSchemaInfo;
    716 
    717         fSchemaInfo = includeInfo;
    718         processChildren(includeInfo->getRoot());
    719         fSchemaInfo = saveInfo;
    720     }
     806void TraverseSchema::traverseInclude(const DOMElement* const elem)
     807{
     808        DEBUG_SCHEMA_MESSAGE
     809        (
     810                "TraverseSchema::traverseInclude("
     811                << elem
     812                << ')'
     813        );
     814
     815        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     816
     817        SchemaInfo* includeInfo = fPreprocessedNodes->get(elem);
     818
     819        if (includeInfo)
     820        {
     821                SchemaInfo* saveInfo = fSchemaInfo;
     822                fSchemaInfo = includeInfo;
     823                processChildren(includeInfo->getRoot());
     824                fSchemaInfo = saveInfo;
     825        }
    721826}
    722827
     
    733838  *    </import>
    734839  */
    735 void TraverseSchema::preprocessImport(const DOMElement* const elem) {
    736 
    737     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    738 
    739     // -----------------------------------------------------------------------
    740     // Check attributes
    741     // -----------------------------------------------------------------------
    742     fAttributeCheck.checkAttributes(
    743         elem, GeneralAttributeCheck::E_Import, this, true, fNonXSAttList);
    744 
    745     // -----------------------------------------------------------------------
    746     // First, handle any ANNOTATION declaration
    747     // -----------------------------------------------------------------------
    748     if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0)
    749         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected);
    750 
    751     if (fAnnotation)
    752         fSchemaGrammar->addAnnotation(fAnnotation);
    753     else if (fScanner->getGenerateSyntheticAnnotations() && fNonXSAttList->size())
    754     {
    755         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    756         fSchemaGrammar->addAnnotation(fAnnotation);
    757     }
    758     // -----------------------------------------------------------------------
    759     // Handle 'namespace' attribute
    760     // -----------------------------------------------------------------------
    761     const XMLCh* nameSpace = getElementAttValue(elem, SchemaSymbols::fgATT_NAMESPACE, DatatypeValidator::AnyURI);
    762     const XMLCh* nameSpaceValue = nameSpace ? nameSpace : XMLUni::fgZeroLenString;
    763 
    764     if (XMLString::equals(nameSpaceValue, fTargetNSURIString)) {
    765 
    766         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Import_1_1);
    767         return;
    768     }
    769 
    770     if (!*nameSpaceValue && fTargetNSURI == fEmptyNamespaceURI) {
    771 
    772         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Import_1_2);
    773         return;
    774     }
    775 
    776     // ------------------------------------------------------------------
    777     // Get 'schemaLocation' attribute
    778     // ------------------------------------------------------------------
    779     const XMLCh* schemaLocation = getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION, DatatypeValidator::AnyURI);
    780 
    781     // ------------------------------------------------------------------
    782     // Resolve namespace to a grammar
    783     // ------------------------------------------------------------------
    784     Grammar* aGrammar = 0;
    785 
    786     {
    787         XMLSchemaDescription* gramDesc =fGrammarResolver->getGrammarPool()->createSchemaDescription(nameSpaceValue);
    788         Janitor<XMLSchemaDescription> janName(gramDesc);
    789         gramDesc->setContextType(XMLSchemaDescription::CONTEXT_IMPORT);
    790         gramDesc->setLocationHints(schemaLocation);
    791         aGrammar = fGrammarResolver->getGrammar(gramDesc);
    792     }
    793 
    794     bool grammarFound = (aGrammar && (aGrammar->getGrammarType() == Grammar::SchemaGrammarType));
    795 
    796     if (grammarFound) {
    797         addImportedNS(fURIStringPool->addOrFind(nameSpaceValue));
    798     }
    799 
    800     // a bare <xs:import/> doesn't load anything
    801     if(!schemaLocation && !nameSpace)
    802         return;
    803 
    804     // ------------------------------------------------------------------
    805     // Resolve schema location
    806     // ------------------------------------------------------------------
    807     fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0,
    808                         ((XSDElementNSImpl*) elem)->getLineNo(),
    809                         ((XSDElementNSImpl*) elem)->getColumnNo());
    810     InputSource* srcToFill = resolveSchemaLocation(schemaLocation,
    811             XMLResourceIdentifier::SchemaImport, nameSpace);
    812 
    813     // Nothing to do
    814     if (!srcToFill) {
    815         if (!grammarFound) {
    816             addImportedNS(fURIStringPool->addOrFind(nameSpaceValue));
    817         }
    818 
    819         return;
    820     }
    821 
    822     Janitor<InputSource> janSrc(srcToFill);
    823     const XMLCh* importURL = srcToFill->getSystemId();
    824     unsigned int nameSpaceId = nameSpace ? fURIStringPool->addOrFind(nameSpace) : fEmptyNamespaceURI;
    825 
    826     SchemaInfo* importSchemaInfo = fCachedSchemaInfoList->get(importURL, nameSpaceId);
    827 
    828     if (!importSchemaInfo && fSchemaInfoList != fCachedSchemaInfoList)
    829       importSchemaInfo = fSchemaInfoList->get(importURL, nameSpaceId);
    830 
    831     if (importSchemaInfo) {
    832         fSchemaInfo->addSchemaInfo(importSchemaInfo, SchemaInfo::IMPORT);
    833         addImportedNS(importSchemaInfo->getTargetNSURI());
    834         return;
    835     }
    836 
    837     if (grammarFound) {
    838         if (!fScanner->getHandleMultipleImports())
    839             return;
    840     }
    841 
    842     // ------------------------------------------------------------------
    843     // Parse input source
    844     // ------------------------------------------------------------------
    845     if (!fParser)
    846         fParser = new (fGrammarPoolMemoryManager) XSDDOMParser(0, fGrammarPoolMemoryManager, 0);
    847 
    848     fParser->setValidationScheme(XercesDOMParser::Val_Never);
    849     fParser->setDoNamespaces(true);
    850     fParser->setUserEntityHandler(fEntityHandler);
    851     fParser->setUserErrorReporter(fErrorReporter);
    852 
    853     // Should just issue warning if the schema is not found
    854     bool flag = srcToFill->getIssueFatalErrorIfNotFound();
    855     srcToFill->setIssueFatalErrorIfNotFound(false);
    856 
    857     fParser->parse(*srcToFill) ;
    858 
    859     // Reset the InputSource
    860     srcToFill->setIssueFatalErrorIfNotFound(flag);
    861 
    862     if (fParser->getSawFatal() && fScanner->getExitOnFirstFatal())
    863         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::SchemaScanFatalError);
    864 
    865     // ------------------------------------------------------------------
    866     // Get root element
    867     // ------------------------------------------------------------------
    868     DOMDocument* document = fParser->getDocument();
    869 
    870     if (document) {
    871 
    872         DOMElement* root = document->getDocumentElement();
    873 
    874         if (!root) {
    875             return;
    876         }
    877 
    878         const XMLCh* targetNSURIString = root->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE);
    879 
    880         if (!XMLString::equals(targetNSURIString, nameSpaceValue)) {
    881             reportSchemaError(root, XMLUni::fgXMLErrDomain, XMLErrs::ImportNamespaceDifference,
    882                               schemaLocation, targetNSURIString, nameSpaceValue);
    883         }
    884         else {
    885 
    886             // --------------------------------------------------------
    887             // Preprocess new schema
    888             // --------------------------------------------------------
    889             SchemaInfo* saveInfo = fSchemaInfo;
    890             fSchemaGrammar->setScopeCount (fScopeCount);
    891             fSchemaGrammar->setAnonTypeCount (fAnonXSTypeCount);
    892             if (grammarFound) {
    893                 fSchemaGrammar = (SchemaGrammar*) aGrammar;
    894             }
    895             else {
    896                 fSchemaGrammar = new (fGrammarPoolMemoryManager) SchemaGrammar(fGrammarPoolMemoryManager);
    897             }
    898             fScopeCount = fSchemaGrammar->getScopeCount ();
    899             fAnonXSTypeCount = fSchemaGrammar->getAnonTypeCount ();
    900 
    901             XMLSchemaDescription* gramDesc = (XMLSchemaDescription*) fSchemaGrammar->getGrammarDescription();
    902             gramDesc->setContextType(XMLSchemaDescription::CONTEXT_IMPORT);
    903             gramDesc->setLocationHints(importURL);
    904 
    905             preprocessSchema(root, importURL, grammarFound);
    906             fPreprocessedNodes->put((void*) elem, fSchemaInfo);
    907 
    908             // --------------------------------------------------------
    909             // Restore old schema information
    910             // --------------------------------------------------------
    911             restoreSchemaInfo(saveInfo, SchemaInfo::IMPORT);
    912         }
    913     }
     840void TraverseSchema::preprocessImport(const DOMElement* const elem)
     841{
     842        DEBUG_SCHEMA_MESSAGE("TraverseSchema::preprocessImport(" << elem << ')');
     843
     844        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     845
     846        // -----------------------------------------------------------------------
     847        // Check attributes
     848        // -----------------------------------------------------------------------
     849        fAttributeCheck.checkAttributes
     850        (
     851                elem, GeneralAttributeCheck::E_Import, this, true, fNonXSAttList
     852        );
     853
     854        // -----------------------------------------------------------------------
     855        // First, handle any ANNOTATION declaration
     856        // -----------------------------------------------------------------------
     857        if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0)
     858        {
     859                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected);
     860        }
     861
     862        if (fAnnotation)
     863        {
     864                fSchemaGrammar->addAnnotation(fAnnotation);
     865        }
     866        else if (fScanner->getGenerateSyntheticAnnotations() && fNonXSAttList->size())
     867        {
     868                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     869                fSchemaGrammar->addAnnotation(fAnnotation);
     870        }
     871        // -----------------------------------------------------------------------
     872        // Handle 'namespace' attribute
     873        // -----------------------------------------------------------------------
     874        const XMLCh* nameSpace = getElementAttValue(elem, SchemaSymbols::fgATT_NAMESPACE, DatatypeValidator::AnyURI);
     875        const XMLCh* nameSpaceValue = nameSpace ? nameSpace : XMLUni::fgZeroLenString;
     876
     877        if (XMLString::equals(nameSpaceValue, fTargetNSURIString))
     878        {
     879                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Import_1_1);
     880                return;
     881        }
     882
     883        if (!*nameSpaceValue && fTargetNSURI == fEmptyNamespaceURI)
     884        {
     885                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::Import_1_2);
     886                return;
     887        }
     888
     889        // ------------------------------------------------------------------
     890        // Get 'schemaLocation' attribute
     891        // ------------------------------------------------------------------
     892        const XMLCh* schemaLocation = getElementAttValue(elem, SchemaSymbols::fgATT_SCHEMALOCATION, DatatypeValidator::AnyURI);
     893
     894        // ------------------------------------------------------------------
     895        // Resolve namespace to a grammar
     896        // ------------------------------------------------------------------
     897        Grammar* aGrammar = 0;
     898
     899        XMLSchemaDescription* gramDesc = fGrammarResolver->getGrammarPool()->createSchemaDescription(nameSpaceValue);
     900        Janitor<XMLSchemaDescription> janName(gramDesc);
     901        gramDesc->setContextType(XMLSchemaDescription::CONTEXT_IMPORT);
     902        gramDesc->setLocationHints(schemaLocation);
     903        aGrammar = fGrammarResolver->getGrammar(gramDesc);
     904
     905        bool grammarFound = (aGrammar && (aGrammar->getGrammarType() == Grammar::SchemaGrammarType));
     906
     907        if (grammarFound)
     908        {
     909                unsigned int uriId = RESOLVE_URI_ID(nameSpaceValue);
     910                addImportedNS(uriId);
     911        }
     912
     913        // a bare <xs:import/> doesn't load anything
     914        if (!schemaLocation && !nameSpace)
     915        {
     916                return;
     917        }
     918
     919        // ------------------------------------------------------------------
     920        // Resolve schema location
     921        // ------------------------------------------------------------------
     922        fLocator->setValues(fSchemaInfo->getCurrentSchemaURL(), 0,
     923                                                ((XSDElementNSImpl*) elem)->getLineNo(),
     924                                                ((XSDElementNSImpl*) elem)->getColumnNo());
     925
     926        InputSource* srcToFill =
     927                resolveSchemaLocation(schemaLocation, XMLResourceIdentifier::SchemaImport, nameSpace);
     928
     929        // Nothing to do
     930        if (!srcToFill)
     931        {
     932                if (!grammarFound)
     933                {
     934                        unsigned int uriId = RESOLVE_URI_ID(nameSpaceValue);
     935                        addImportedNS(uriId);
     936                }
     937                return;
     938        }
     939
     940        Janitor<InputSource> janSrc(srcToFill);
     941        const XMLCh* importURL = srcToFill->getSystemId();
     942        unsigned int nameSpaceId = RESOLVE_URI_ID(nameSpace);
     943        SchemaInfo* importSchemaInfo = fCachedSchemaInfoList->get(importURL, nameSpaceId);
     944
     945        if (!importSchemaInfo && fSchemaInfoList != fCachedSchemaInfoList)
     946        {
     947                importSchemaInfo = fSchemaInfoList->get(importURL, nameSpaceId);
     948        }
     949
     950        if (importSchemaInfo)
     951        {
     952                fSchemaInfo->addSchemaInfo(importSchemaInfo, SchemaInfo::IMPORT);
     953
     954                addImportedNS(importSchemaInfo->getTargetNSURI());
     955                return;
     956        }
     957
     958        if (grammarFound)
     959        {
     960                if (!fScanner->getHandleMultipleImports())
     961                {
     962                        return;
     963                }
     964        }
     965
     966        // ------------------------------------------------------------------
     967        // Parse input source
     968        // ------------------------------------------------------------------
     969        if (!fParser)
     970        {
     971                fParser = new (fGrammarPoolMemoryManager) XSDDOMParser(0, fGrammarPoolMemoryManager, 0);
     972        }
     973
     974
     975        fParser->setValidationScheme(XercesDOMParser::Val_Never);
     976        fParser->getScanner()->setUriResolver(fUriResolver);
     977        fParser->setDoNamespaces(true);
     978        fParser->setUserEntityHandler(fEntityHandler);
     979        fParser->setUserErrorReporter(fErrorReporter);
     980
     981        // Should just issue warning if the schema is not found
     982        bool flag = srcToFill->getIssueFatalErrorIfNotFound();
     983        srcToFill->setIssueFatalErrorIfNotFound(false);
     984
     985        fParser->parse(*srcToFill) ;
     986
     987        // Reset the InputSource
     988        srcToFill->setIssueFatalErrorIfNotFound(flag);
     989
     990        if (fParser->getSawFatal() && fScanner->getExitOnFirstFatal())
     991                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::SchemaScanFatalError);
     992
     993        // ------------------------------------------------------------------
     994        // Get root element
     995        // ------------------------------------------------------------------
     996        DOMDocument* document = fParser->getDocument();
     997
     998        DEBUG_SCHEMA_MESSAGE("preprocessImport::fParser->getDocument()=" << (fParser->getDocument() != 0));
     999
     1000        if (document)
     1001        {
     1002                DOMElement* root = document->getDocumentElement();
     1003                if (!root)
     1004                {
     1005                        return;
     1006                }
     1007
     1008                const XMLCh* targetNSURIString = root->getAttribute(SchemaSymbols::fgATT_TARGETNAMESPACE);
     1009
     1010                if (!XMLString::equals(targetNSURIString, nameSpaceValue))
     1011                {
     1012                        reportSchemaError(root, XMLUni::fgXMLErrDomain, XMLErrs::ImportNamespaceDifference,
     1013                                                          schemaLocation, targetNSURIString, nameSpaceValue);
     1014                }
     1015                else
     1016                {
     1017                        // --------------------------------------------------------
     1018                        // Preprocess new schema
     1019                        // --------------------------------------------------------
     1020                        SchemaInfo* saveInfo = fSchemaInfo;
     1021                        fSchemaGrammar->setScopeCount (fScopeCount);
     1022                        fSchemaGrammar->setAnonTypeCount (fAnonXSTypeCount);
     1023                        if (grammarFound)
     1024                        {
     1025                                fSchemaGrammar = (SchemaGrammar*) aGrammar;
     1026                        }
     1027                        else
     1028                        {
     1029                                fSchemaGrammar = new (fGrammarPoolMemoryManager) SchemaGrammar(fGrammarPoolMemoryManager);
     1030                        }
     1031                        fScopeCount = fSchemaGrammar->getScopeCount();
     1032                        fAnonXSTypeCount = fSchemaGrammar->getAnonTypeCount ();
     1033
     1034                        XMLSchemaDescription* gramDesc = (XMLSchemaDescription*) fSchemaGrammar->getGrammarDescription();
     1035                        gramDesc->setContextType(XMLSchemaDescription::CONTEXT_IMPORT);
     1036                        gramDesc->setLocationHints(importURL);
     1037
     1038                        preprocessSchema(root, importURL, grammarFound);
     1039                        fPreprocessedNodes->put((void*) elem, fSchemaInfo);
     1040
     1041                        // --------------------------------------------------------
     1042                        // Restore old schema information
     1043                        // --------------------------------------------------------
     1044                        restoreSchemaInfo(saveInfo, SchemaInfo::IMPORT);
     1045                }
     1046        }
    9141047}
    9151048
    9161049
    917 void TraverseSchema::traverseImport(const DOMElement* const elem) {
    918 
    919     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    920 
    921     SchemaInfo* importInfo = fPreprocessedNodes->get(elem);
    922 
    923     if (importInfo) {
    924 
    925         // --------------------------------------------------------
    926         // Traverse new schema
    927         // --------------------------------------------------------
    928         SchemaInfo* saveInfo = fSchemaInfo;
    929 
    930         restoreSchemaInfo(importInfo, SchemaInfo::IMPORT);
    931         doTraverseSchema(importInfo->getRoot());
    932 
    933         // --------------------------------------------------------
    934         // Restore old schema information
    935         // --------------------------------------------------------
    936         restoreSchemaInfo(saveInfo, SchemaInfo::IMPORT);
    937     }
     1050void TraverseSchema::traverseImport(const DOMElement* const elem)
     1051{
     1052        DEBUG_SCHEMA_MESSAGE("TraverseSchema::traverseImport(" << elem << ')');
     1053
     1054        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     1055        SchemaInfo* importInfo = fPreprocessedNodes->get(elem);
     1056
     1057        DEBUG_SCHEMA_MESSAGE("->importInfo=" << importInfo);
     1058
     1059        if (importInfo)
     1060        {
     1061                // --------------------------------------------------------
     1062                // Traverse new schema
     1063                // --------------------------------------------------------
     1064                SchemaInfo* saveInfo = fSchemaInfo;
     1065
     1066                restoreSchemaInfo(importInfo, SchemaInfo::IMPORT);
     1067                doTraverseSchema(importInfo->getRoot());
     1068
     1069                // --------------------------------------------------------
     1070                // Restore old schema information
     1071                // --------------------------------------------------------
     1072                restoreSchemaInfo(saveInfo, SchemaInfo::IMPORT);
     1073        }
    9381074}
    9391075
     
    9491085  *    </redefine>
    9501086  */
    951 void TraverseSchema::preprocessRedefine(const DOMElement* const redefineElem) {
    952 
    953     NamespaceScopeManager nsMgr(redefineElem, fSchemaInfo, this);
    954 
    955     // -----------------------------------------------------------------------
    956     // Check attributes
    957     // -----------------------------------------------------------------------
    958     fAttributeCheck.checkAttributes(
    959         redefineElem, GeneralAttributeCheck::E_Redefine, this, true
    960     );
    961 
    962     // First, we look through the children of redefineElem. Each one will
    963     // correspond to an element of the redefined schema that we need to
    964     // redefine.  To do this, we rename the element of the redefined schema,
    965     // and rework the base or ref tag of the kid we're working on to refer to
    966     // the renamed group or derive the renamed type.  Once we've done this, we
    967     // actually go through the schema being redefined and convert it to a
    968     // grammar. Only then do we run through redefineDecl's kids and put them
    969     // in the grammar.
    970     SchemaInfo* redefiningInfo = fSchemaInfo;
    971 
    972     if (!openRedefinedSchema(redefineElem)) {
    973 
    974         redefiningInfo->addFailedRedefine(redefineElem);
    975         return;
    976     }
    977 
    978     if (!fRedefineComponents) {
    979         fRedefineComponents = new (fMemoryManager) RefHash2KeysTableOf<XMLCh>(13, (bool) false, fMemoryManager);
    980     }
    981 
    982     SchemaInfo* redefinedInfo = fSchemaInfo;
    983     renameRedefinedComponents(redefineElem, redefiningInfo, redefinedInfo);
    984 
    985     // Now we have to preprocess our nicely-renamed schemas.
    986     if (fPreprocessedNodes->containsKey(redefineElem)) {
    987 
    988         fSchemaInfo = redefinedInfo;
    989         preprocessChildren(fSchemaInfo->getRoot());
    990     }
    991 
    992     fSchemaInfo = redefiningInfo;
     1087void TraverseSchema::preprocessRedefine(const DOMElement* const redefineElem)
     1088{
     1089        DEBUG_SCHEMA_MESSAGE
     1090        (
     1091                "TraverseSchema::preprocessRedefine("
     1092                << redefineElem
     1093                << ')'
     1094        );
     1095
     1096        NamespaceScopeManager nsMgr(redefineElem, fSchemaInfo, this);
     1097
     1098        // -----------------------------------------------------------------------
     1099        // Check attributes
     1100        // -----------------------------------------------------------------------
     1101        fAttributeCheck.checkAttributes
     1102        (
     1103                redefineElem, GeneralAttributeCheck::E_Redefine, this, true
     1104        );
     1105
     1106        // First, we look through the children of redefineElem. Each one will
     1107        // correspond to an element of the redefined schema that we need to
     1108        // redefine.  To do this, we rename the element of the redefined schema,
     1109        // and rework the base or ref tag of the kid we're working on to refer to
     1110        // the renamed group or derive the renamed type.  Once we've done this, we
     1111        // actually go through the schema being redefined and convert it to a
     1112        // grammar. Only then do we run through redefineDecl's kids and put them
     1113        // in the grammar.
     1114        SchemaInfo* redefiningInfo = fSchemaInfo;
     1115
     1116        if (!openRedefinedSchema(redefineElem))
     1117        {
     1118                redefiningInfo->addFailedRedefine(redefineElem);
     1119                return;
     1120        }
     1121
     1122        if (!fRedefineComponents)
     1123        {
     1124                fRedefineComponents = new (fMemoryManager) RefHash2KeysTableOf<XMLCh>(13, (bool) false, fMemoryManager);
     1125        }
     1126
     1127        SchemaInfo* redefinedInfo = fSchemaInfo;
     1128        renameRedefinedComponents(redefineElem, redefiningInfo, redefinedInfo);
     1129
     1130        // Now we have to preprocess our nicely-renamed schemas.
     1131        if (fPreprocessedNodes->containsKey(redefineElem))
     1132        {
     1133                fSchemaInfo = redefinedInfo;
     1134                preprocessChildren(fSchemaInfo->getRoot());
     1135        }
     1136
     1137        fSchemaInfo = redefiningInfo;
    9931138}
    9941139
    995 void TraverseSchema::traverseRedefine(const DOMElement* const redefineElem) {
    996 
    997     NamespaceScopeManager nsMgr(redefineElem, fSchemaInfo, this);
    998 
    999     SchemaInfo* saveInfo = fSchemaInfo;
    1000     SchemaInfo* redefinedInfo = fPreprocessedNodes->get(redefineElem);
    1001 
    1002     if (redefinedInfo) {
    1003 
    1004         // Now we have to march through our nicely-renamed schemas. When
    1005         // we do these traversals other <redefine>'s may perhaps be
    1006         // encountered; we leave recursion to sort this out.
    1007         fSchemaInfo = redefinedInfo;
    1008         processChildren(fSchemaInfo->getRoot());
    1009         fSchemaInfo = saveInfo;
    1010 
    1011         // Now traverse our own <redefine>
    1012         processChildren(redefineElem);
    1013     }
     1140void TraverseSchema::traverseRedefine(const DOMElement* const redefineElem)
     1141{
     1142        DEBUG_SCHEMA_MESSAGE
     1143        (
     1144                "TraverseSchema::traverseRedefine("
     1145                << redefineElem
     1146                << ')'
     1147        );
     1148
     1149        NamespaceScopeManager nsMgr(redefineElem, fSchemaInfo, this);
     1150        SchemaInfo* saveInfo = fSchemaInfo;
     1151        SchemaInfo* redefinedInfo = fPreprocessedNodes->get(redefineElem);
     1152
     1153        if (redefinedInfo)
     1154        {
     1155                // Now we have to march through our nicely-renamed schemas. When
     1156                // we do these traversals other <redefine>'s may perhaps be
     1157                // encountered; we leave recursion to sort this out.
     1158                fSchemaInfo = redefinedInfo;
     1159                processChildren(fSchemaInfo->getRoot());
     1160                fSchemaInfo = saveInfo;
     1161
     1162                // Now traverse our own <redefine>
     1163                processChildren(redefineElem);
     1164        }
    10141165}
    10151166
     
    10271178ContentSpecNode*
    10281179TraverseSchema::traverseChoiceSequence(const DOMElement* const elem,
    1029                                        const int modelGroupType,
    1030                                        bool& hasChildren)
    1031 {
    1032     hasChildren = false;
    1033     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    1034 
    1035     // -----------------------------------------------------------------------
    1036     // Check attributes
    1037     // -----------------------------------------------------------------------
    1038     fAttributeCheck.checkAttributes(
    1039         elem, GeneralAttributeCheck::E_Sequence, this, false, fNonXSAttList
    1040     );
    1041 
    1042     // -----------------------------------------------------------------------
    1043     // Process contents
    1044     // -----------------------------------------------------------------------
    1045     DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true);
    1046     if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    1047     {
    1048         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    1049     }
    1050     Janitor<XSAnnotation> janAnnot(fAnnotation);
    1051     Janitor<ContentSpecNode>    left(0);
    1052     Janitor<ContentSpecNode>    right(0);
    1053 
    1054     bool hadContent = false;
    1055 
    1056     Janitor<ContentSpecNode> contentSpecNode(0);
    1057     for (; child != 0; child = XUtil::getNextSiblingElement(child)) {
    1058         hasChildren = true;
    1059         contentSpecNode.release();
    1060         bool seeParticle = false;
    1061         bool wasAny = false;
    1062         const XMLCh* childName = child->getLocalName();
    1063 
    1064         if (XMLString::equals(childName, SchemaSymbols::fgELT_ELEMENT)) {
    1065 
    1066             SchemaElementDecl* elemDecl = traverseElementDecl(child);
    1067 
    1068             if (!elemDecl )
    1069                 continue;
    1070 
    1071             contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode
    1072             (
    1073                 elemDecl
    1074                 , fGrammarPoolMemoryManager
    1075             ));
    1076             seeParticle = true;
    1077         }
    1078         else if (XMLString::equals(childName, SchemaSymbols::fgELT_GROUP)) {
    1079 
    1080             XercesGroupInfo* grpInfo = traverseGroupDecl(child, false);
    1081 
    1082             if (!grpInfo) {
    1083                 continue;
    1084             }
    1085 
    1086             ContentSpecNode* grpContentSpecNode = grpInfo->getContentSpec();
    1087 
    1088             if (!grpContentSpecNode) {
    1089                 continue;
    1090             }
    1091 
    1092             if (grpContentSpecNode->hasAllContent()) {
    1093 
    1094                 reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AllContentLimited);
    1095                 continue;
    1096             }
    1097 
    1098             contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode(*grpContentSpecNode));
    1099             seeParticle = true;
    1100         }
    1101         else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE)) {
    1102             bool hasChild;
    1103             contentSpecNode.reset(traverseChoiceSequence(child,ContentSpecNode::Choice, hasChild));
    1104             seeParticle = true;
    1105         }
    1106         else if (XMLString::equals(childName, SchemaSymbols::fgELT_SEQUENCE)) {
    1107             bool hasChild;
    1108             contentSpecNode.reset(traverseChoiceSequence(child,ContentSpecNode::Sequence, hasChild));
    1109             seeParticle = true;
    1110         }
    1111         else if (XMLString::equals(childName, SchemaSymbols::fgELT_ANY)) {
    1112 
    1113             contentSpecNode.reset(traverseAny(child));
    1114             seeParticle = true;
    1115             wasAny = true;
    1116         }
    1117         else {
    1118             reportSchemaError(child, XMLUni::fgValidityDomain, XMLValid::GroupContentRestricted,
    1119                               childName,
    1120                               ((ContentSpecNode::NodeTypes) modelGroupType) == ContentSpecNode::Choice?SchemaSymbols::fgELT_CHOICE:SchemaSymbols::fgELT_SEQUENCE);
    1121         }
    1122 
    1123         if (seeParticle) {
    1124             checkMinMax(contentSpecNode.get(), child, Not_All_Context);
    1125             if (wasAny && contentSpecNode.get()->getMaxOccurs() == 0) {
    1126                 contentSpecNode.reset(0);
    1127             }
    1128         }
    1129 
    1130         if (contentSpecNode.get()) {
    1131             hadContent = true;
    1132         }
    1133 
    1134         if (left.get() == 0) {
    1135             left.reset(contentSpecNode.release());
    1136         }
    1137         else if (right.get() == 0) {
    1138             right.reset(contentSpecNode.release());
    1139         }
    1140         else {
    1141             ContentSpecNode* newNode =
    1142                    new (fGrammarPoolMemoryManager) ContentSpecNode
    1143             (
    1144                 (ContentSpecNode::NodeTypes) modelGroupType
    1145                 , left.get()
    1146                 , right.get()
    1147                 , true
    1148                 , true
    1149                 , fGrammarPoolMemoryManager
    1150             );
    1151 
    1152             left.release();
    1153             right.release();
    1154 
    1155             left.reset(newNode);
    1156             right.reset(contentSpecNode.release());
    1157         }
    1158     }
    1159     contentSpecNode.release();
    1160 
    1161     if (hadContent)
    1162     {
    1163         ContentSpecNode* newNode =
    1164                new (fGrammarPoolMemoryManager) ContentSpecNode
    1165         (
    1166             ((ContentSpecNode::NodeTypes) modelGroupType) == ContentSpecNode::Choice
    1167                 ? ContentSpecNode::ModelGroupChoice : ContentSpecNode::ModelGroupSequence
    1168             , left.get()
    1169             , right.get()
    1170             , true
    1171             , true
    1172             , fGrammarPoolMemoryManager
    1173         );
    1174 
    1175         left.release();
    1176 
    1177         left.reset(newNode);
    1178 
    1179         if (!janAnnot.isDataNull())
    1180             fSchemaGrammar->putAnnotation(left.get(), janAnnot.release());
    1181     }
    1182 
    1183     right.release();
    1184     return left.release();
     1180                                                                           const int modelGroupType,
     1181                                                                           bool & hasChildren)
     1182{
     1183        DEBUG_SCHEMA_MESSAGE
     1184        (
     1185                "TraverseSchema::traverseChoiceSequence("
     1186                << elem
     1187                << ',' << modelGroupType
     1188                << ')'
     1189        );
     1190
     1191        hasChildren = false;
     1192        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     1193
     1194        // -----------------------------------------------------------------------
     1195        // Check attributes
     1196        // -----------------------------------------------------------------------
     1197        fAttributeCheck.checkAttributes
     1198        (
     1199                elem, GeneralAttributeCheck::E_Sequence, this, false, fNonXSAttList
     1200        );
     1201
     1202        // -----------------------------------------------------------------------
     1203        // Process contents
     1204        // -----------------------------------------------------------------------
     1205        const DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true);
     1206        if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     1207        {
     1208                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     1209        }
     1210        Janitor<XSAnnotation> janAnnot(fAnnotation);
     1211        Janitor<ContentSpecNode>    left(0);
     1212        Janitor<ContentSpecNode>    right(0);
     1213
     1214        bool hadContent = false;
     1215
     1216        Janitor<ContentSpecNode> contentSpecNode(0);
     1217        for (; child; child = XUtil::getNextSiblingElement(child))
     1218        {
     1219                hasChildren = true;
     1220                contentSpecNode.release();
     1221                bool seeParticle = false;
     1222                bool wasAny = false;
     1223                const XMLCh* childName = child->getLocalName();
     1224
     1225                if (XMLString::equals(childName, SchemaSymbols::fgELT_ELEMENT))
     1226                {
     1227                        SchemaElementDecl* elemDecl = traverseElementDecl(child);
     1228
     1229                        if (!elemDecl)
     1230                                continue;
     1231
     1232                        contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode
     1233                        (
     1234                                elemDecl
     1235                                , fGrammarPoolMemoryManager
     1236                        ));
     1237                        seeParticle = true;
     1238                }
     1239                else if (XMLString::equals(childName, SchemaSymbols::fgELT_GROUP))
     1240                {
     1241                        const XercesGroupInfo* grpInfo = traverseGroupDecl(child, false);
     1242
     1243                        if (!grpInfo)
     1244                        {
     1245                                continue;
     1246                        }
     1247
     1248                        ContentSpecNode* grpContentSpecNode = grpInfo->getContentSpec();
     1249                        if (!grpContentSpecNode)
     1250                        {
     1251                                continue;
     1252                        }
     1253
     1254                        if (grpContentSpecNode->hasAllContent())
     1255                        {
     1256                                reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AllContentLimited);
     1257                                continue;
     1258                        }
     1259
     1260                        contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode(*grpContentSpecNode));
     1261                        seeParticle = true;
     1262                }
     1263                else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE))
     1264                {
     1265                        bool hasChild;
     1266                        contentSpecNode.reset(traverseChoiceSequence(child,ContentSpecNode::Choice, hasChild));
     1267                        seeParticle = true;
     1268                }
     1269                else if (XMLString::equals(childName, SchemaSymbols::fgELT_SEQUENCE))
     1270                {
     1271                        bool hasChild;
     1272                        contentSpecNode.reset(traverseChoiceSequence(child,ContentSpecNode::Sequence, hasChild));
     1273                        seeParticle = true;
     1274                }
     1275                else if (XMLString::equals(childName, SchemaSymbols::fgELT_ANY))
     1276                {
     1277                        contentSpecNode.reset(traverseAny(child));
     1278                        seeParticle = true;
     1279                        wasAny = true;
     1280                }
     1281                else
     1282                {
     1283                        reportSchemaError
     1284                        (
     1285                                child
     1286                                , XMLUni::fgValidityDomain
     1287                                , XMLValid::GroupContentRestricted
     1288                                , childName
     1289                                , ((ContentSpecNode::NodeTypes) modelGroupType) == ContentSpecNode::Choice?SchemaSymbols::fgELT_CHOICE:SchemaSymbols::fgELT_SEQUENCE);
     1290                }
     1291
     1292                if (seeParticle)
     1293                {
     1294                        checkMinMax(contentSpecNode.get(), child, Not_All_Context);
     1295                        if (wasAny && contentSpecNode.get()->getMaxOccurs() == 0)
     1296                        {
     1297                                contentSpecNode.reset(0);
     1298                        }
     1299                }
     1300
     1301                if (contentSpecNode.get())
     1302                {
     1303                        hadContent = true;
     1304                }
     1305
     1306                if (left.get() == 0)
     1307                {
     1308                        left.reset(contentSpecNode.release());
     1309                }
     1310                else if (right.get() == 0)
     1311                {
     1312                        right.reset(contentSpecNode.release());
     1313                }
     1314                else
     1315                {
     1316                        ContentSpecNode* newNode =
     1317                                   new (fGrammarPoolMemoryManager) ContentSpecNode
     1318                        (
     1319                                (ContentSpecNode::NodeTypes) modelGroupType
     1320                                , left.get()
     1321                                , right.get()
     1322                                , true
     1323                                , true
     1324                                , fGrammarPoolMemoryManager
     1325                        );
     1326
     1327                        left.release();
     1328                        right.release();
     1329
     1330                        left.reset(newNode);
     1331                        right.reset(contentSpecNode.release());
     1332                }
     1333        }
     1334        contentSpecNode.release();
     1335
     1336        if (hadContent)
     1337        {
     1338                ContentSpecNode* newNode =
     1339                           new (fGrammarPoolMemoryManager) ContentSpecNode
     1340                (
     1341                        ((ContentSpecNode::NodeTypes) modelGroupType) == ContentSpecNode::Choice
     1342                                ? ContentSpecNode::ModelGroupChoice : ContentSpecNode::ModelGroupSequence
     1343                        , left.get()
     1344                        , right.get()
     1345                        , true
     1346                        , true
     1347                        , fGrammarPoolMemoryManager
     1348                );
     1349
     1350                left.release();
     1351
     1352                left.reset(newNode);
     1353
     1354                if (!janAnnot.isDataNull())
     1355                        fSchemaGrammar->putAnnotation(left.get(), janAnnot.release());
     1356        }
     1357
     1358        right.release();
     1359
     1360        return left.release();
    11851361}
    11861362
     
    11971373DatatypeValidator*
    11981374TraverseSchema::traverseSimpleTypeDecl(const DOMElement* const childElem,
    1199                                        const bool topLevel, int baseRefContext)
    1200 {
    1201     NamespaceScopeManager nsMgr(childElem, fSchemaInfo, this);
    1202 
    1203     // ------------------------------------------------------------------
    1204     // Process contents
    1205     // ------------------------------------------------------------------
    1206     const XMLCh* name = getElementAttValue(childElem,SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
    1207     bool nameEmpty = (!name || !*name);
    1208 
    1209     if (topLevel && nameEmpty) {
    1210         reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement,
    1211                           SchemaSymbols::fgELT_SIMPLETYPE);
    1212         return 0;
    1213     }
    1214     else if(!topLevel && !nameEmpty) {
    1215         reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeDisallowedLocal,
    1216                           SchemaSymbols::fgATT_NAME, childElem->getLocalName());
    1217         return 0;
    1218     }
    1219 
    1220     if (nameEmpty) { // anonymous simpleType
    1221         name = genAnonTypeName(fgAnonSNamePrefix);
    1222     }
    1223     else if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)) ) {
    1224 
    1225         reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
    1226                           SchemaSymbols::fgELT_SIMPLETYPE, name);
    1227         return 0;
    1228     }
    1229 
    1230     fBuffer.set(fTargetNSURIString);
    1231     fBuffer.append(chComma);
    1232     fBuffer.append(name);
    1233 
    1234     unsigned int fullTypeNameId = fStringPool->addOrFind(fBuffer.getRawBuffer());
    1235     const XMLCh* fullName = fStringPool->getValueForId(fullTypeNameId);
    1236 
    1237     //check if we have already traversed the same simpleType decl
    1238     DatatypeValidator* dv = fDatatypeRegistry->getDatatypeValidator(fullName);
    1239 
    1240     if (!dv) {
    1241 
    1242         // -------------------------------------------------------------------
    1243         // Check attributes
    1244         // -------------------------------------------------------------------
    1245         unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_SimpleTypeGlobal
    1246                                           : GeneralAttributeCheck::E_SimpleTypeLocal;
    1247 
    1248         fAttributeCheck.checkAttributes(
    1249             childElem, scope, this, topLevel, fNonXSAttList
    1250         );
    1251 
    1252         // Circular constraint checking
    1253         if (fCurrentTypeNameStack->containsElement(fullTypeNameId)) {
    1254 
    1255             reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, name);
    1256             return 0;
    1257         }
    1258 
    1259         fCurrentTypeNameStack->addElement(fullTypeNameId);
    1260 
    1261         // Get 'final' values
    1262         int finalSet = parseFinalSet(childElem, S_Final);
    1263 
    1264         // annotation?,(list|restriction|union)
    1265         DOMElement* content= checkContent(
    1266             childElem, XUtil::getFirstChildElement(childElem), false);
    1267         if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    1268         {
    1269             fAnnotation = generateSyntheticAnnotation(childElem, fNonXSAttList);
    1270         }
    1271         Janitor<XSAnnotation> janAnnot(fAnnotation);
    1272         if (content == 0) {
    1273 
    1274             reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::EmptySimpleTypeContent);
    1275             popCurrentTypeNameStack();
    1276             return 0;
    1277         }
    1278 
    1279         const XMLCh* varietyName = content->getLocalName();
    1280 
    1281         // Remark: some code will be repeated in list|restriction| union but it
    1282         //         is cleaner that way
    1283         if (XMLString::equals(varietyName, SchemaSymbols::fgELT_LIST)) { //traverse List
    1284             if ((baseRefContext & SchemaSymbols::XSD_LIST) != 0) {
    1285 
    1286                 reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AtomicItemType);
    1287                 popCurrentTypeNameStack();
    1288                 return 0;
    1289             }
    1290 
    1291             dv = traverseByList(childElem, content, name, fullName, finalSet, &janAnnot);
    1292         }
    1293         else if (XMLString::equals(varietyName, SchemaSymbols::fgELT_RESTRICTION)) { //traverse Restriction
    1294             dv = traverseByRestriction(childElem, content, name, fullName, finalSet, &janAnnot);
    1295         }
    1296         else if (XMLString::equals(varietyName, SchemaSymbols::fgELT_UNION)) { //traverse union
    1297             dv = traverseByUnion(childElem, content, name, fullName, finalSet, baseRefContext, &janAnnot);
    1298         }
    1299         else {
    1300             reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::FeatureUnsupported, varietyName);
    1301             popCurrentTypeNameStack();
    1302         }
    1303 
    1304         if (dv) {
    1305             if (nameEmpty)
    1306                 dv->setAnonymous();
    1307 
    1308             if (!janAnnot.isDataNull())
    1309                 fSchemaGrammar->putAnnotation(dv, janAnnot.release());
    1310         }
    1311     }
    1312 
    1313     return dv;
     1375                                                                           const bool topLevel, int baseRefContext)
     1376{
     1377        DEBUG_SCHEMA_MESSAGE
     1378        (
     1379                "TraverseSchema::traverseSimpleTypeDecl("
     1380                << childElem
     1381                << ',' << topLevel
     1382                << ',' << baseRefContext
     1383                << ')'
     1384        );
     1385
     1386        NamespaceScopeManager nsMgr(childElem, fSchemaInfo, this);
     1387
     1388        // ------------------------------------------------------------------
     1389        // Process contents
     1390        // ------------------------------------------------------------------
     1391        const XMLCh* name = getElementAttValue(childElem,SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
     1392        bool nameEmpty = (!name || !*name);
     1393
     1394        if (topLevel && nameEmpty)
     1395        {
     1396                reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement,
     1397                                                  SchemaSymbols::fgELT_SIMPLETYPE);
     1398                return 0;
     1399        }
     1400        else if(!topLevel && !nameEmpty)
     1401        {
     1402                reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeDisallowedLocal,
     1403                                                  SchemaSymbols::fgATT_NAME, childElem->getLocalName());
     1404                return 0;
     1405        }
     1406
     1407        if (nameEmpty)
     1408        { // anonymous simpleType
     1409                name = genAnonTypeName(fgAnonSNamePrefix);
     1410        }
     1411        else if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)))
     1412        {
     1413                reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
     1414                                                  SchemaSymbols::fgELT_SIMPLETYPE, name);
     1415                return 0;
     1416        }
     1417
     1418        fBuffer.set(fTargetNSURIString);
     1419        fBuffer.append(chComma);
     1420        fBuffer.append(name);
     1421
     1422        unsigned int fullTypeNameId = fStringPool->addOrFind(fBuffer.getRawBuffer());
     1423        const XMLCh* fullName = fStringPool->getValueForId(fullTypeNameId);
     1424
     1425        //check if we have already traversed the same simpleType decl
     1426        DatatypeValidator* dv = fDatatypeRegistry->getDatatypeValidator(fullName);
     1427
     1428        if (!dv)
     1429        {
     1430                // -------------------------------------------------------------------
     1431                // Check attributes
     1432                // -------------------------------------------------------------------
     1433                unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_SimpleTypeGlobal
     1434                                                                                  : GeneralAttributeCheck::E_SimpleTypeLocal;
     1435
     1436                fAttributeCheck.checkAttributes(childElem, scope, this, topLevel, fNonXSAttList);
     1437
     1438                // Circular constraint checking
     1439                if (fCurrentTypeNameStack->containsElement(fullTypeNameId))
     1440                {
     1441                        reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, name);
     1442                        return 0;
     1443                }
     1444
     1445                fCurrentTypeNameStack->addElement(fullTypeNameId);
     1446
     1447                // Get 'final' values
     1448                int finalSet = parseFinalSet(childElem, S_Final);
     1449
     1450                // annotation?,(list|restriction|union)
     1451                DOMElement* content= checkContent(childElem, XUtil::getFirstChildElement(childElem), false);
     1452
     1453                if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     1454                {
     1455                        fAnnotation = generateSyntheticAnnotation(childElem, fNonXSAttList);
     1456                }
     1457
     1458                Janitor<XSAnnotation> janAnnot(fAnnotation);
     1459                if (content == 0)
     1460                {
     1461                        reportSchemaError(childElem, XMLUni::fgXMLErrDomain, XMLErrs::EmptySimpleTypeContent);
     1462                        popCurrentTypeNameStack();
     1463                        return 0;
     1464                }
     1465
     1466                const XMLCh* varietyName = content->getLocalName();
     1467
     1468                // Remark: some code will be repeated in list|restriction| union but it
     1469                //         is cleaner that way
     1470                if (XMLString::equals(varietyName, SchemaSymbols::fgELT_LIST)) { //traverse List
     1471                        if ((baseRefContext & SchemaSymbols::XSD_LIST) != 0) {
     1472
     1473                                reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AtomicItemType);
     1474                                popCurrentTypeNameStack();
     1475                                return 0;
     1476                        }
     1477
     1478                        dv = traverseByList(childElem, content, name, fullName, finalSet, &janAnnot);
     1479                }
     1480                else if (XMLString::equals(varietyName, SchemaSymbols::fgELT_RESTRICTION)) { //traverse Restriction
     1481                        dv = traverseByRestriction(childElem, content, name, fullName, finalSet, &janAnnot);
     1482                }
     1483                else if (XMLString::equals(varietyName, SchemaSymbols::fgELT_UNION)) { //traverse union
     1484                        dv = traverseByUnion(childElem, content, name, fullName, finalSet, baseRefContext, &janAnnot);
     1485                }
     1486                else
     1487                {
     1488                        reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::FeatureUnsupported, varietyName);
     1489                        popCurrentTypeNameStack();
     1490                }
     1491
     1492                if (dv)
     1493                {
     1494                        if (nameEmpty)
     1495                                dv->setAnonymous();
     1496
     1497                        if (!janAnnot.isDataNull())
     1498                                fSchemaGrammar->putAnnotation(dv, janAnnot.release());
     1499                }
     1500        }
     1501
     1502        return dv;
    13141503}
    13151504
     
    13301519  */
    13311520int TraverseSchema::traverseComplexTypeDecl(const DOMElement* const elem,
    1332                                             const bool topLevel,
    1333                                             const XMLCh* const recursingTypeName) {
    1334 
    1335     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    1336 
    1337     // Get the attributes of the complexType
    1338     const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
    1339     bool isAnonymous = false;
    1340 
    1341     if (!name || !*name) {
    1342 
    1343         if (topLevel) {
    1344 
    1345             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelNoNameComplexType);
    1346             return -1;
    1347         }
    1348 
    1349         if (recursingTypeName)
    1350             name = recursingTypeName;
    1351         else {
    1352             name = genAnonTypeName(fgAnonCNamePrefix);
    1353             isAnonymous = true;
    1354         }
    1355     }
    1356 
    1357     if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)) ) {
    1358 
    1359         //REVISIT - Should we return or continue and save type with wrong name?
    1360         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
    1361                           SchemaSymbols::fgELT_COMPLEXTYPE, name);
    1362         return -1;
    1363     }
    1364 
    1365     // ------------------------------------------------------------------
    1366     // Check if the type has already been registered
    1367     // ------------------------------------------------------------------
    1368     fBuffer.set(fTargetNSURIString);
    1369     fBuffer.append(chComma);
    1370     fBuffer.append(name);
    1371 
    1372     int typeNameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
    1373     const XMLCh* fullName = fStringPool->getValueForId(typeNameIndex);
    1374     ComplexTypeInfo* typeInfo = 0;
    1375 
    1376     if (topLevel || recursingTypeName) {
    1377 
    1378         typeInfo = fComplexTypeRegistry->get(fullName);
    1379 
    1380         if (typeInfo && !typeInfo->getPreprocessed()) {
    1381             return typeNameIndex;
    1382         }
    1383     }
    1384 
    1385     // -----------------------------------------------------------------------
    1386     // Check Attributes
    1387     // -----------------------------------------------------------------------
    1388     bool preProcessFlag = (typeInfo) ? typeInfo->getPreprocessed() : false;
    1389     if (!preProcessFlag) {
    1390         fAttributeCheck.checkAttributes(
    1391             elem, (topLevel) ? GeneralAttributeCheck::E_ComplexTypeGlobal
    1392                              : GeneralAttributeCheck::E_ComplexTypeLocal
    1393             , this, topLevel, fNonXSAttList
    1394         );
    1395     }
    1396 
    1397     // -----------------------------------------------------------------------
    1398     // Create a new instance
    1399     // -----------------------------------------------------------------------
    1400     XMLSize_t previousCircularCheckIndex = fCircularCheckIndex;
    1401     unsigned int previousScope = fCurrentScope;
    1402 
    1403     if (preProcessFlag) {
    1404 
    1405         fCurrentScope = typeInfo->getScopeDefined();
    1406         typeInfo->setPreprocessed(false);
    1407     }
    1408     else {
    1409 
    1410         // ------------------------------------------------------------------
    1411         // Register the type
    1412         // ------------------------------------------------------------------
    1413         typeInfo = new (fGrammarPoolMemoryManager) ComplexTypeInfo(fGrammarPoolMemoryManager);
    1414         if(isAnonymous) {
    1415             typeInfo->setAnonymous();
    1416         }
    1417 
    1418         fCurrentScope = fScopeCount++;
    1419         fComplexTypeRegistry->put((void*) fullName, typeInfo);
    1420         typeInfo->setTypeName(fullName);
    1421         typeInfo->setScopeDefined(fCurrentScope);
    1422 
    1423         if (fFullConstraintChecking) {
    1424 
    1425             XSDLocator* aLocator = new (fGrammarPoolMemoryManager) XSDLocator();
    1426             aLocator->setValues(fStringPool->getValueForId(fStringPool->addOrFind(fSchemaInfo->getCurrentSchemaURL())),
    1427                                 0, ((XSDElementNSImpl*) elem)->getLineNo(),
    1428                                 ((XSDElementNSImpl*) elem)->getColumnNo());
    1429             typeInfo->setLocator(aLocator);
    1430         }
    1431     }
    1432 
    1433     fCurrentTypeNameStack->addElement(typeNameIndex);
    1434     ComplexTypeInfo* saveTypeInfo = fCurrentComplexType;
    1435     fCurrentComplexType = typeInfo;
    1436 
    1437     // ------------------------------------------------------------------
    1438     // First, handle any ANNOTATION declaration and get next child
    1439     // ------------------------------------------------------------------
    1440     DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true, !preProcessFlag);
    1441 
    1442     if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    1443     {
    1444         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    1445     }
    1446     Janitor<XSAnnotation> janAnnot(fAnnotation);
    1447 
    1448     // ------------------------------------------------------------------
    1449     // Process the content of the complex type declaration
    1450     // ------------------------------------------------------------------
    1451     try {
    1452 
    1453         const XMLCh* mixedVal = getElementAttValue(elem,SchemaSymbols::fgATT_MIXED, DatatypeValidator::Boolean);
    1454         bool isMixed = false;
    1455 
    1456         if ((mixedVal && *mixedVal)
    1457             && (XMLString::equals(SchemaSymbols::fgATTVAL_TRUE, mixedVal)
    1458                 || XMLString::equals(fgValueOne, mixedVal))) {
    1459             isMixed = true;
    1460         }
    1461 
    1462         if (child == 0) {
    1463             // EMPTY complexType with complexContent
    1464             processComplexContent(elem, name, child, typeInfo, 0, isMixed);
    1465         }
    1466         else {
    1467 
    1468             const XMLCh* childName = child->getLocalName();
    1469 
    1470             if (XMLString::equals(childName, SchemaSymbols::fgELT_SIMPLECONTENT)) {
    1471 
    1472                 // SIMPLE CONTENT element
    1473                 traverseSimpleContentDecl(name, fullName, child, typeInfo, &janAnnot);
    1474 
    1475                 if (XUtil::getNextSiblingElement(child) != 0) {
    1476                     reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildFollowingSimpleContent);
    1477                 }
    1478             }
    1479             else if (XMLString::equals(childName, SchemaSymbols::fgELT_COMPLEXCONTENT)) {
    1480 
    1481                 // COMPLEX CONTENT element
    1482                 traverseComplexContentDecl(name, child, typeInfo, isMixed, &janAnnot);
    1483 
    1484                 if (XUtil::getNextSiblingElement(child) != 0) {
    1485                     reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildFollowingConplexContent);
    1486                 }
    1487             }
    1488             else if (fCurrentGroupInfo) {
    1489                 typeInfo->setPreprocessed(true);
    1490             }
    1491             else {
    1492                 // We must have ....
    1493                 // GROUP, ALL, SEQUENCE or CHOICE, followed by optional attributes
    1494                 // Note that it's possible that only attributes are specified.
    1495                 processComplexContent(elem, name, child, typeInfo, 0, isMixed);
    1496             }
    1497         }
    1498     }
    1499     catch(const TraverseSchema::ExceptionCodes aCode) {
    1500         if (aCode == TraverseSchema::InvalidComplexTypeInfo)
    1501             defaultComplexTypeInfo(typeInfo);
    1502         else if (aCode == TraverseSchema::RecursingElement)
    1503             typeInfo->setPreprocessed();
    1504     }
    1505 
    1506     // ------------------------------------------------------------------
    1507     // Finish the setup of the typeInfo
    1508     // ------------------------------------------------------------------
    1509     if (!preProcessFlag) {
    1510 
    1511         const XMLCh* abstractAttVal = getElementAttValue(elem, SchemaSymbols::fgATT_ABSTRACT, DatatypeValidator::Boolean);
    1512         int blockSet = parseBlockSet(elem, C_Block);
    1513         int finalSet = parseFinalSet(elem, EC_Final);
    1514 
    1515         typeInfo->setBlockSet(blockSet);
    1516         typeInfo->setFinalSet(finalSet);
    1517 
    1518         if ((abstractAttVal && *abstractAttVal)
    1519             && (XMLString::equals(abstractAttVal, SchemaSymbols::fgATTVAL_TRUE)
    1520                 || XMLString::equals(abstractAttVal, fgValueOne))) {
    1521             typeInfo->setAbstract(true);
    1522         }
    1523         else {
    1524             typeInfo->setAbstract(false);
    1525         }
    1526     }
    1527 
    1528     // Store Annotation
    1529     if (!janAnnot.isDataNull())
    1530         fSchemaGrammar->putAnnotation(typeInfo, janAnnot.release());
    1531 
    1532     // ------------------------------------------------------------------
    1533     // Before exiting, restore the scope, mainly for nested anonymous types
    1534     // ------------------------------------------------------------------
    1535     popCurrentTypeNameStack();
    1536     fCircularCheckIndex = previousCircularCheckIndex;
    1537     fCurrentScope = previousScope;
    1538     fCurrentComplexType = saveTypeInfo;
    1539 
    1540     return typeNameIndex;
     1521                                                                                        const bool topLevel,
     1522                                                                                        const XMLCh* const recursingTypeName)
     1523{
     1524        DEBUG_SCHEMA_MESSAGE("TraverseSchema::traverseComplexTypeDecl(" << elem << ',' << topLevel << ',' << recursingTypeName << ')');
     1525
     1526        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     1527
     1528        // Get the attributes of the complexType
     1529        const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
     1530        bool isAnonymous = false;
     1531
     1532        if (!name || !*name)
     1533        {
     1534                if (topLevel)
     1535                {
     1536                        reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelNoNameComplexType);
     1537                        return -1;
     1538                }
     1539
     1540                if (recursingTypeName)
     1541                        name = recursingTypeName;
     1542                else
     1543                {
     1544                        name = genAnonTypeName(fgAnonCNamePrefix);
     1545                        isAnonymous = true;
     1546                }
     1547        }
     1548
     1549        if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)))
     1550        {
     1551                //REVISIT - Should we return or continue and save type with wrong name?
     1552                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
     1553                                                  SchemaSymbols::fgELT_COMPLEXTYPE, name);
     1554                return -1;
     1555        }
     1556
     1557        // ------------------------------------------------------------------
     1558        // Check if the type has already been registered
     1559        // ------------------------------------------------------------------
     1560        fBuffer.set(fTargetNSURIString);
     1561        fBuffer.append(chComma);
     1562        fBuffer.append(name);
     1563
     1564        int typeNameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
     1565        const XMLCh* fullName = fStringPool->getValueForId(typeNameIndex);
     1566        ComplexTypeInfo* typeInfo = 0;
     1567
     1568        if (topLevel || recursingTypeName)
     1569        {
     1570                typeInfo = fComplexTypeRegistry->get(fullName);
     1571
     1572                if (typeInfo && !typeInfo->getPreprocessed())
     1573                {
     1574                        return typeNameIndex;
     1575                }
     1576        }
     1577
     1578        // -----------------------------------------------------------------------
     1579        // Check Attributes
     1580        // -----------------------------------------------------------------------
     1581        bool preProcessFlag = (typeInfo) ? typeInfo->getPreprocessed() : false;
     1582        if (!preProcessFlag) {
     1583                fAttributeCheck.checkAttributes(
     1584                        elem, (topLevel) ? GeneralAttributeCheck::E_ComplexTypeGlobal
     1585                                                         : GeneralAttributeCheck::E_ComplexTypeLocal
     1586                        , this, topLevel, fNonXSAttList
     1587                );
     1588        }
     1589
     1590        // -----------------------------------------------------------------------
     1591        // Create a new instance
     1592        // -----------------------------------------------------------------------
     1593        XMLSize_t previousCircularCheckIndex = fCircularCheckIndex;
     1594        unsigned int previousScope = fCurrentScope;
     1595
     1596        if (preProcessFlag)
     1597        {
     1598                fCurrentScope = typeInfo->getScopeDefined();
     1599                typeInfo->setPreprocessed(false);
     1600        }
     1601        else
     1602        {
     1603                // ------------------------------------------------------------------
     1604                // Register the type
     1605                // ------------------------------------------------------------------
     1606                typeInfo = new (fGrammarPoolMemoryManager) ComplexTypeInfo(fGrammarPoolMemoryManager);
     1607                if(isAnonymous)
     1608                {
     1609                        typeInfo->setAnonymous();
     1610                }
     1611
     1612                fCurrentScope = fScopeCount++;
     1613
     1614                fComplexTypeRegistry->put((void*) fullName, typeInfo);
     1615                typeInfo->setTypeName(fullName);
     1616                typeInfo->setScopeDefined(fCurrentScope);
     1617
     1618                if (fFullConstraintChecking)
     1619                {
     1620                        XSDLocator* aLocator = new (fGrammarPoolMemoryManager) XSDLocator();
     1621                        aLocator->setValues
     1622                        (
     1623                                fStringPool->getValueForId(fStringPool->addOrFind(fSchemaInfo->getCurrentSchemaURL()))
     1624                                , 0
     1625                                , ((XSDElementNSImpl*) elem)->getLineNo()
     1626                                , ((XSDElementNSImpl*) elem)->getColumnNo()
     1627                        );
     1628
     1629                        typeInfo->setLocator(aLocator);
     1630                }
     1631        }
     1632
     1633        fCurrentTypeNameStack->addElement(typeNameIndex);
     1634        ComplexTypeInfo* saveTypeInfo = fCurrentComplexType;
     1635        fCurrentComplexType = typeInfo;
     1636
     1637        // ------------------------------------------------------------------
     1638        // First, handle any ANNOTATION declaration and get next child
     1639        // ------------------------------------------------------------------
     1640        DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true, !preProcessFlag);
     1641
     1642        if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     1643        {
     1644                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     1645        }
     1646        Janitor<XSAnnotation> janAnnot(fAnnotation);
     1647
     1648        // ------------------------------------------------------------------
     1649        // Process the content of the complex type declaration
     1650        // ------------------------------------------------------------------
     1651        try
     1652        {
     1653                const XMLCh* mixedVal = getElementAttValue(elem,SchemaSymbols::fgATT_MIXED, DatatypeValidator::Boolean);
     1654                bool isMixed = false;
     1655
     1656                if ((mixedVal && *mixedVal)
     1657                        && (XMLString::equals(SchemaSymbols::fgATTVAL_TRUE, mixedVal)
     1658                                || XMLString::equals(fgValueOne, mixedVal))) {
     1659                        isMixed = true;
     1660                }
     1661
     1662                if (child == 0)
     1663                {
     1664                        // EMPTY complexType with complexContent
     1665                        processComplexContent(elem, name, child, typeInfo, 0, isMixed);
     1666                }
     1667                else
     1668                {
     1669                        const XMLCh* childName = child->getLocalName();
     1670
     1671                        if (XMLString::equals(childName, SchemaSymbols::fgELT_SIMPLECONTENT))
     1672                        {
     1673                                // SIMPLE CONTENT element
     1674                                traverseSimpleContentDecl(name, fullName, child, typeInfo, &janAnnot);
     1675
     1676                                if (XUtil::getNextSiblingElement(child) != 0)
     1677                                {
     1678                                        reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildFollowingSimpleContent);
     1679                                }
     1680                        }
     1681                        else if (XMLString::equals(childName, SchemaSymbols::fgELT_COMPLEXCONTENT))
     1682                        {
     1683                                // COMPLEX CONTENT element
     1684                                traverseComplexContentDecl(name, child, typeInfo, isMixed, &janAnnot);
     1685
     1686                                if (XUtil::getNextSiblingElement(child) != 0)
     1687                                {
     1688                                        reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::InvalidChildFollowingConplexContent);
     1689                                }
     1690                        }
     1691                        else if (fCurrentGroupInfo)
     1692                        {
     1693                                typeInfo->setPreprocessed(true);
     1694                        }
     1695                        else
     1696                        {
     1697                                // We must have ....
     1698                                // GROUP, ALL, SEQUENCE or CHOICE, followed by optional attributes
     1699                                // Note that it's possible that only attributes are specified.
     1700                                processComplexContent(elem, name, child, typeInfo, 0, isMixed);
     1701                        }
     1702                }
     1703        }
     1704        catch(const TraverseSchema::ExceptionCodes aCode) {
     1705                if (aCode == TraverseSchema::InvalidComplexTypeInfo)
     1706                        defaultComplexTypeInfo(typeInfo);
     1707                else if (aCode == TraverseSchema::RecursingElement)
     1708                        typeInfo->setPreprocessed();
     1709        }
     1710
     1711        // ------------------------------------------------------------------
     1712        // Finish the setup of the typeInfo
     1713        // ------------------------------------------------------------------
     1714        if (!preProcessFlag)
     1715        {
     1716                const XMLCh* abstractAttVal = getElementAttValue(elem, SchemaSymbols::fgATT_ABSTRACT, DatatypeValidator::Boolean);
     1717                int blockSet = parseBlockSet(elem, C_Block);
     1718                int finalSet = parseFinalSet(elem, EC_Final);
     1719
     1720                typeInfo->setBlockSet(blockSet);
     1721                typeInfo->setFinalSet(finalSet);
     1722
     1723                if ((abstractAttVal && *abstractAttVal)
     1724                        && (XMLString::equals(abstractAttVal, SchemaSymbols::fgATTVAL_TRUE)
     1725                                || XMLString::equals(abstractAttVal, fgValueOne)))
     1726                {
     1727                        typeInfo->setAbstract(true);
     1728                }
     1729                else
     1730                {
     1731                        typeInfo->setAbstract(false);
     1732                }
     1733        }
     1734
     1735        // Store Annotation
     1736        if (!janAnnot.isDataNull())
     1737                fSchemaGrammar->putAnnotation(typeInfo, janAnnot.release());
     1738
     1739        // ------------------------------------------------------------------
     1740        // Before exiting, restore the scope, mainly for nested anonymous types
     1741        // ------------------------------------------------------------------
     1742        popCurrentTypeNameStack();
     1743        fCircularCheckIndex = previousCircularCheckIndex;
     1744        fCurrentScope = previousScope;
     1745        fCurrentComplexType = saveTypeInfo;
     1746
     1747        return typeNameIndex;
    15411748}
    15421749
     
    15561763XercesGroupInfo*
    15571764TraverseSchema::traverseGroupDecl(const DOMElement* const elem,
    1558                                   const bool topLevel) {
    1559 
    1560     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    1561 
    1562     const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
    1563     const XMLCh* ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
    1564     bool         nameEmpty = (!name || !*name);
    1565     bool         refEmpty = (!ref || !*ref);
    1566 
    1567     if (nameEmpty && topLevel) {
    1568         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement,
    1569                           SchemaSymbols::fgELT_GROUP);
    1570         return 0;
    1571     }
    1572 
    1573     if (nameEmpty && refEmpty) {
    1574         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefGroup);
    1575         return 0;
    1576     }
    1577 
    1578     // ------------------------------------------------------------------
    1579     // Check attributes
    1580     // ------------------------------------------------------------------
    1581     unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_GroupGlobal
    1582                                       : GeneralAttributeCheck::E_GroupRef;
    1583     fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList);
    1584 
    1585     // ------------------------------------------------------------------
    1586     // Handle "ref="
    1587     // ------------------------------------------------------------------
    1588     if (!topLevel) {
    1589 
    1590         if (refEmpty) {
    1591             return 0;
    1592         }
    1593 
    1594         return processGroupRef(elem, ref);
    1595     }
    1596 
    1597     // name must be a valid NCName
    1598     if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) {
    1599         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
    1600                           SchemaSymbols::fgELT_GROUP, name);
    1601         return 0;
    1602     }
    1603 
    1604     fBuffer.set(fTargetNSURIString);
    1605     fBuffer.append(chComma);
    1606     fBuffer.append(name);
    1607 
    1608     unsigned int nameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
    1609     const XMLCh* fullName = fStringPool->getValueForId(nameIndex);
    1610     XercesGroupInfo* groupInfo = fGroupRegistry->get(fullName);
    1611 
    1612     if (groupInfo) {
    1613         return groupInfo;
    1614     }
    1615 
    1616     // ------------------------------------------------------------------
    1617     // Check for annotations
    1618     // ------------------------------------------------------------------
    1619     DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true);
    1620     if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    1621     {
    1622         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    1623     }
    1624     Janitor<XSAnnotation> janAnnot(fAnnotation);
    1625     // ------------------------------------------------------------------
    1626     // Process contents of global groups
    1627     // ------------------------------------------------------------------
    1628     unsigned int saveScope = fCurrentScope;
    1629     Janitor<ContentSpecNode> specNode(0);
    1630     XercesGroupInfo* saveGroupInfo = fCurrentGroupInfo;
    1631 
    1632     Janitor<XercesGroupInfo>    newGroupInfoJan(new (fGrammarPoolMemoryManager) XercesGroupInfo(
    1633         fStringPool->addOrFind(name), fTargetNSURI, fGrammarPoolMemoryManager));
    1634     fCurrentGroupStack->addElement(nameIndex);
    1635     XercesGroupInfo* const newGroupInfo = newGroupInfoJan.get();
    1636     fCurrentGroupInfo = newGroupInfo;
    1637 
    1638     fCurrentScope = fScopeCount++;
    1639     fCurrentGroupInfo->setScope(fCurrentScope);
    1640 
    1641     if (content == 0) {
    1642         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::GroupContentError, name);
    1643     }
    1644     else {
    1645 
    1646         if (content->getAttributeNode(SchemaSymbols::fgATT_MINOCCURS) != 0
    1647             || content->getAttributeNode(SchemaSymbols::fgATT_MAXOCCURS) != 0) {
    1648             reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::MinMaxOnGroupChild);
    1649         }
    1650 
    1651         bool illegalChild = false;
    1652         const XMLCh* childName = content->getLocalName();
    1653         bool hasChild;
    1654 
    1655 
    1656         if (XMLString::equals(childName, SchemaSymbols::fgELT_SEQUENCE)) {
    1657             specNode.reset(traverseChoiceSequence(content, ContentSpecNode::Sequence, hasChild));
    1658         }
    1659         else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE)) {
    1660             specNode.reset(traverseChoiceSequence(content, ContentSpecNode::Choice, hasChild));
    1661         }
    1662         else if (XMLString::equals(childName, SchemaSymbols::fgELT_ALL)) {
    1663             specNode.reset(traverseAll(content, hasChild));
    1664         }
    1665         else {
    1666             illegalChild = true;
    1667         }
    1668 
    1669         if (illegalChild || XUtil::getNextSiblingElement(content) != 0) {
    1670             reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::GroupContentError, name);
    1671         }
    1672 
    1673         // copy local elements to complex type if it exists
    1674         if (fCurrentComplexType)
    1675            processElements(elem, fCurrentGroupInfo, fCurrentComplexType);
    1676     }
    1677 
    1678     // ------------------------------------------------------------------
    1679     // Set groupInfo and pop group name from stack
    1680     // ------------------------------------------------------------------
    1681     XMLSize_t stackSize = fCurrentGroupStack->size();
    1682 
    1683     if (stackSize != 0) {
    1684         fCurrentGroupStack->removeElementAt(stackSize - 1);
    1685     }
    1686 
    1687     fCurrentGroupInfo->setContentSpec(specNode.release());
    1688     fGroupRegistry->put((void*) fullName, fCurrentGroupInfo);
    1689     newGroupInfoJan.release();
    1690     fCurrentGroupInfo = saveGroupInfo;
    1691     fCurrentScope = saveScope;
    1692 
    1693     // Store Annotation
    1694     if (!janAnnot.isDataNull()) {
    1695         fSchemaGrammar->putAnnotation(newGroupInfo, janAnnot.release());
    1696     }
    1697 
    1698     if (fFullConstraintChecking) {
    1699 
    1700         XSDLocator* aLocator = new (fGrammarPoolMemoryManager) XSDLocator();
    1701 
    1702         newGroupInfo->setLocator(aLocator);
    1703         aLocator->setValues(fStringPool->getValueForId(fStringPool->addOrFind(fSchemaInfo->getCurrentSchemaURL())),
    1704                             0, ((XSDElementNSImpl*) elem)->getLineNo(),
    1705                             ((XSDElementNSImpl*) elem)->getColumnNo());
    1706 
    1707         if (fRedefineComponents && fRedefineComponents->get(SchemaSymbols::fgELT_GROUP, nameIndex))
    1708         {
    1709 
    1710             fBuffer.set(fullName);
    1711             fBuffer.append(SchemaSymbols::fgRedefIdentifier);
    1712             unsigned int rdfNameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
    1713 
    1714             if (fCurrentGroupStack->containsElement(rdfNameIndex))
    1715             {
    1716                 reportSchemaError(aLocator, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, name);
    1717             }
    1718             else
    1719             {
    1720                 XercesGroupInfo* baseGroup = fGroupRegistry->get(fBuffer.getRawBuffer());
    1721                 if (baseGroup)
    1722                 {
    1723                     newGroupInfo->setBaseGroup(baseGroup);
    1724                 }
    1725                 else
    1726                 {
    1727                     fBuffer.set(name);
    1728                     fBuffer.append(SchemaSymbols::fgRedefIdentifier);
    1729                     SchemaInfo* saveInfo  = fSchemaInfo;
    1730                     DOMElement* groupElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_Group,
    1731                         SchemaSymbols::fgELT_GROUP, fBuffer.getRawBuffer(), &fSchemaInfo);
    1732 
    1733                     if (groupElem != 0) {
    1734                         baseGroup = traverseGroupDecl(groupElem);
    1735                         newGroupInfo->setBaseGroup(baseGroup);
    1736                         fSchemaInfo = saveInfo;
    1737                     }
    1738                     else
    1739                     {
    1740                         reportSchemaError(aLocator, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNotFound,
    1741                         SchemaSymbols::fgELT_GROUP, fTargetNSURIString, fBuffer.getRawBuffer());
    1742                     }
    1743                 }
    1744             }
    1745         }
    1746     }
    1747 
    1748     return newGroupInfo;
     1765                                                                  const bool topLevel)
     1766{
     1767        DEBUG_SCHEMA_MESSAGE("TraverseSchema::traverseGroupDecl(" << elem << ',' << topLevel << ')');
     1768
     1769        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     1770
     1771        const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
     1772        const XMLCh* ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
     1773        bool         nameEmpty = (!name || !*name);
     1774        bool         refEmpty = (!ref || !*ref);
     1775
     1776        if (nameEmpty && topLevel)
     1777        {
     1778                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement,
     1779                                                  SchemaSymbols::fgELT_GROUP);
     1780                return 0;
     1781        }
     1782
     1783        if (nameEmpty && refEmpty)
     1784        {
     1785                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefGroup);
     1786                return 0;
     1787        }
     1788
     1789        // ------------------------------------------------------------------
     1790        // Check attributes
     1791        // ------------------------------------------------------------------
     1792        unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_GroupGlobal
     1793                                                                          : GeneralAttributeCheck::E_GroupRef;
     1794        fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList);
     1795
     1796        // ------------------------------------------------------------------
     1797        // Handle "ref="
     1798        // ------------------------------------------------------------------
     1799        if (!topLevel)
     1800        {
     1801                if (refEmpty)
     1802                {
     1803                        return 0;
     1804                }
     1805
     1806                return processGroupRef(elem, ref);
     1807        }
     1808
     1809        // name must be a valid NCName
     1810        if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)))
     1811        {
     1812                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
     1813                                                  SchemaSymbols::fgELT_GROUP, name);
     1814                return 0;
     1815        }
     1816
     1817        fBuffer.set(fTargetNSURIString);
     1818        fBuffer.append(chComma);
     1819        fBuffer.append(name);
     1820
     1821        unsigned int nameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
     1822        const XMLCh* fullName = fStringPool->getValueForId(nameIndex);
     1823        XercesGroupInfo* groupInfo = fGroupRegistry->get(fullName);
     1824
     1825        if (groupInfo)
     1826        {
     1827                return groupInfo;
     1828        }
     1829
     1830        // ------------------------------------------------------------------
     1831        // Check for annotations
     1832        // ------------------------------------------------------------------
     1833        DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true);
     1834        if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     1835        {
     1836                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     1837        }
     1838        Janitor<XSAnnotation> janAnnot(fAnnotation);
     1839        // ------------------------------------------------------------------
     1840        // Process contents of global groups
     1841        // ------------------------------------------------------------------
     1842        unsigned int saveScope = fCurrentScope;
     1843        Janitor<ContentSpecNode> specNode(0);
     1844        XercesGroupInfo* saveGroupInfo = fCurrentGroupInfo;
     1845
     1846        Janitor<XercesGroupInfo> newGroupInfoJan
     1847        (
     1848                new (fGrammarPoolMemoryManager) XercesGroupInfo
     1849                (
     1850                        fStringPool->addOrFind(name)
     1851                        , fTargetNSURI
     1852                        , fGrammarPoolMemoryManager
     1853                )
     1854        );
     1855
     1856        fCurrentGroupStack->addElement(nameIndex);
     1857        XercesGroupInfo* const newGroupInfo = newGroupInfoJan.get();
     1858        fCurrentGroupInfo = newGroupInfo;
     1859
     1860        fCurrentScope = fScopeCount++;
     1861        fCurrentGroupInfo->setScope(fCurrentScope);
     1862
     1863        if (content == 0)
     1864        {
     1865                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::GroupContentError, name);
     1866        }
     1867        else
     1868        {
     1869                if (content->getAttributeNode(SchemaSymbols::fgATT_MINOCCURS) != 0
     1870                        || content->getAttributeNode(SchemaSymbols::fgATT_MAXOCCURS) != 0) {
     1871                        reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::MinMaxOnGroupChild);
     1872                }
     1873
     1874                bool illegalChild = false;
     1875                const XMLCh* childName = content->getLocalName();
     1876                bool hasChild;
     1877
     1878
     1879                if (XMLString::equals(childName, SchemaSymbols::fgELT_SEQUENCE))
     1880                {
     1881                        specNode.reset(traverseChoiceSequence(content, ContentSpecNode::Sequence, hasChild));
     1882                }
     1883                else if (XMLString::equals(childName, SchemaSymbols::fgELT_CHOICE))
     1884                {
     1885                        specNode.reset(traverseChoiceSequence(content, ContentSpecNode::Choice, hasChild));
     1886                }
     1887                else if (XMLString::equals(childName, SchemaSymbols::fgELT_ALL))
     1888                {
     1889                        specNode.reset(traverseAll(content, hasChild));
     1890                }
     1891                else
     1892                {
     1893                        illegalChild = true;
     1894                }
     1895
     1896                if (illegalChild || XUtil::getNextSiblingElement(content) != 0)
     1897                {
     1898                        reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::GroupContentError, name);
     1899                }
     1900
     1901                // copy local elements to complex type if it exists
     1902                if (fCurrentComplexType)
     1903                   processElements(elem, fCurrentGroupInfo, fCurrentComplexType);
     1904        }
     1905
     1906        // ------------------------------------------------------------------
     1907        // Set groupInfo and pop group name from stack
     1908        // ------------------------------------------------------------------
     1909        XMLSize_t stackSize = fCurrentGroupStack->size();
     1910
     1911        if (stackSize != 0)
     1912        {
     1913                fCurrentGroupStack->removeElementAt(stackSize - 1);
     1914        }
     1915
     1916        fCurrentGroupInfo->setContentSpec(specNode.release());
     1917        fGroupRegistry->put((void*) fullName, fCurrentGroupInfo);
     1918        newGroupInfoJan.release();
     1919        fCurrentGroupInfo = saveGroupInfo;
     1920        fCurrentScope = saveScope;
     1921
     1922        // Store Annotation
     1923        if (!janAnnot.isDataNull())
     1924        {
     1925                fSchemaGrammar->putAnnotation(newGroupInfo, janAnnot.release());
     1926        }
     1927
     1928        if (fFullConstraintChecking)
     1929        {
     1930                XSDLocator* aLocator = new (fGrammarPoolMemoryManager) XSDLocator();
     1931
     1932                newGroupInfo->setLocator(aLocator);
     1933                aLocator->setValues
     1934                (
     1935                        fStringPool->getValueForId(fStringPool->addOrFind(fSchemaInfo->getCurrentSchemaURL()))
     1936                        , 0
     1937                        , ((XSDElementNSImpl*) elem)->getLineNo()
     1938                        , ((XSDElementNSImpl*) elem)->getColumnNo()
     1939                );
     1940
     1941                if (fRedefineComponents && fRedefineComponents->get(SchemaSymbols::fgELT_GROUP, nameIndex))
     1942                {
     1943
     1944                        fBuffer.set(fullName);
     1945                        fBuffer.append(SchemaSymbols::fgRedefIdentifier);
     1946                        unsigned int rdfNameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
     1947
     1948                        if (fCurrentGroupStack->containsElement(rdfNameIndex))
     1949                        {
     1950                                reportSchemaError(aLocator, XMLUni::fgXMLErrDomain, XMLErrs::NoCircularDefinition, name);
     1951                        }
     1952                        else
     1953                        {
     1954                                XercesGroupInfo* baseGroup = fGroupRegistry->get(fBuffer.getRawBuffer());
     1955                                if (baseGroup)
     1956                                {
     1957                                        newGroupInfo->setBaseGroup(baseGroup);
     1958                                }
     1959                                else
     1960                                {
     1961                                        fBuffer.set(name);
     1962                                        fBuffer.append(SchemaSymbols::fgRedefIdentifier);
     1963                                        SchemaInfo* saveInfo  = fSchemaInfo;
     1964                                        DOMElement* groupElem = fSchemaInfo->getTopLevelComponent(SchemaInfo::C_Group,
     1965                                                SchemaSymbols::fgELT_GROUP, fBuffer.getRawBuffer(), &fSchemaInfo);
     1966
     1967                                        if (groupElem != 0) {
     1968                                                baseGroup = traverseGroupDecl(groupElem);
     1969                                                newGroupInfo->setBaseGroup(baseGroup);
     1970                                                fSchemaInfo = saveInfo;
     1971                                        }
     1972                                        else
     1973                                        {
     1974                                                reportSchemaError(aLocator, XMLUni::fgXMLErrDomain, XMLErrs::DeclarationNotFound,
     1975                                                SchemaSymbols::fgELT_GROUP, fTargetNSURIString, fBuffer.getRawBuffer());
     1976                                        }
     1977                                }
     1978                        }
     1979                }
     1980        }
     1981
     1982        return newGroupInfo;
    17491983}
    17501984
     
    17631997XercesAttGroupInfo*
    17641998TraverseSchema::traverseAttributeGroupDecl(const DOMElement* const elem,
    1765                                            ComplexTypeInfo* const typeInfo,
    1766                                            const bool topLevel) {
    1767 
    1768     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    1769 
    1770     const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
    1771     const XMLCh* ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
    1772     bool         nameEmpty = (!name || !*name) ? true : false;
    1773     bool         refEmpty = (!ref || !*ref) ? true : false;
    1774 
    1775     if (nameEmpty && topLevel) {
    1776         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement,
    1777             SchemaSymbols::fgELT_ATTRIBUTEGROUP);
    1778         return 0;
    1779     }
    1780 
    1781     if (nameEmpty && refEmpty) {
    1782         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefAttGroup);
    1783         return 0;
    1784     }
    1785 
    1786     // ------------------------------------------------------------------
    1787     // Check attributes
    1788     // ------------------------------------------------------------------
    1789     unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_AttributeGroupGlobal
    1790                                       : GeneralAttributeCheck::E_AttributeGroupRef;
    1791     fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList);
    1792 
    1793     // ------------------------------------------------------------------
    1794     // Handle "ref="
    1795     // ------------------------------------------------------------------
    1796     XercesAttGroupInfo* attGroupInfo;
    1797     Janitor<XercesAttGroupInfo> janAttGroupInfo(0);
    1798     if (!topLevel) {
    1799 
    1800         if (refEmpty) {
    1801             return 0;
    1802         }
    1803 
    1804         attGroupInfo = processAttributeGroupRef(elem, ref, typeInfo);
    1805     }
    1806     else
    1807     {
    1808         // name must be a valid NCName
    1809         if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))) {
    1810             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
    1811                               SchemaSymbols::fgELT_ATTRIBUTEGROUP, name);
    1812             return 0;
    1813         }
    1814 
    1815         // Check for annotations
    1816         DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true);
    1817         if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    1818         {
    1819             fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    1820         }
    1821         Janitor<XSAnnotation> janAnnot(fAnnotation);
    1822 
    1823         // Process contents of global attributeGroups
    1824         XercesAttGroupInfo* saveAttGroupInfo = fCurrentAttGroupInfo;
    1825         janAttGroupInfo.reset(new (fGrammarPoolMemoryManager) XercesAttGroupInfo(
    1826             fStringPool->addOrFind(name), fTargetNSURI, fGrammarPoolMemoryManager));
    1827 
    1828         fDeclStack->addElement(elem);
    1829         fCurrentAttGroupInfo = janAttGroupInfo.get();
    1830 
    1831         for (; content !=0; content = XUtil::getNextSiblingElement(content)) {
    1832 
    1833             if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ATTRIBUTE)) {
    1834                 traverseAttributeDecl(content, typeInfo);
    1835             }
    1836             else if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ATTRIBUTEGROUP)) {
    1837                 traverseAttributeGroupDecl(content, typeInfo);
    1838             }
    1839             else {
    1840                 break;
    1841             }
    1842         }
    1843 
    1844         if (content != 0) {
    1845 
    1846             if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ANYATTRIBUTE)) {
    1847 
    1848                 SchemaAttDef* anyAtt = traverseAnyAttribute(content);
    1849 
    1850                 if (anyAtt) {
    1851                     fCurrentAttGroupInfo->addAnyAttDef(anyAtt);
    1852                 }
    1853 
    1854                 if (XUtil::getNextSiblingElement(content) != 0) {
    1855                     reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AttGroupContentError, name);
    1856                 }
    1857             }
    1858             else {
    1859                 reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AttGroupContentError, name);
    1860             }
    1861         }
    1862 
    1863         // Pop declaration
    1864         fDeclStack->removeElementAt(fDeclStack->size() - 1);
    1865 
    1866         fAttGroupRegistry->put((void*) fStringPool->getValueForId(fStringPool->addOrFind(name)), janAttGroupInfo.get());
    1867         // Restore old attGroupInfo
    1868         attGroupInfo = janAttGroupInfo.release();
    1869         fCurrentAttGroupInfo = saveAttGroupInfo;
    1870 
    1871         // Check Attribute Derivation Restriction OK
    1872         fBuffer.set(fTargetNSURIString);
    1873         fBuffer.append(chComma);
    1874         fBuffer.append(name);
    1875 
    1876         unsigned int nameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
    1877 
    1878         if (fRedefineComponents && fRedefineComponents->get(SchemaSymbols::fgELT_ATTRIBUTEGROUP, nameIndex)) {
    1879 
    1880             fBuffer.set(name);
    1881             fBuffer.append(SchemaSymbols::fgRedefIdentifier);
    1882             XercesAttGroupInfo* baseAttGroupInfo = fAttGroupRegistry->get(fBuffer.getRawBuffer());
    1883 
    1884             if (baseAttGroupInfo)
    1885                 checkAttDerivationOK(elem, baseAttGroupInfo, attGroupInfo);
    1886         }
    1887 
    1888         // Store annotation
    1889         if (!janAnnot.isDataNull())
    1890             fSchemaGrammar->putAnnotation(attGroupInfo, janAnnot.release());
    1891     }
    1892 
    1893     // calculate complete wildcard if necessary
    1894     if (attGroupInfo)
    1895     {
    1896         XMLSize_t anyAttCount = attGroupInfo->anyAttributeCount();
    1897         if (anyAttCount && !attGroupInfo->getCompleteWildCard())
    1898         {
    1899             SchemaAttDef* attGroupWildCard =  new (fGrammarPoolMemoryManager)
    1900                 SchemaAttDef(attGroupInfo->anyAttributeAt(0));
    1901 
    1902             for (XMLSize_t k= 1; k < anyAttCount; k++)
    1903                 attWildCardIntersection(attGroupWildCard, attGroupInfo->anyAttributeAt(k));
    1904 
    1905             attGroupInfo->setCompleteWildCard(attGroupWildCard);
    1906         }
    1907     }
    1908 
    1909     return attGroupInfo;
     1999                                                                                   ComplexTypeInfo* const typeInfo,
     2000                                                                                   const bool topLevel)
     2001{
     2002        DEBUG_SCHEMA_MESSAGE
     2003        (
     2004                "TraverseSchema::traverseAttributeGroupDecl("
     2005                << elem
     2006                << ',' << typeInfo
     2007                << ',' << topLevel
     2008                << ')'
     2009        );
     2010
     2011        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     2012
     2013        const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
     2014        const XMLCh* ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
     2015        bool         nameEmpty = (!name || !*name) ? true : false;
     2016        bool         refEmpty = (!ref || !*ref) ? true : false;
     2017
     2018        if (nameEmpty && topLevel)
     2019        {
     2020                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameGlobalElement, SchemaSymbols::fgELT_ATTRIBUTEGROUP);
     2021                return 0;
     2022        }
     2023
     2024        if (nameEmpty && refEmpty)
     2025        {
     2026                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefAttGroup);
     2027                return 0;
     2028        }
     2029
     2030        // ------------------------------------------------------------------
     2031        // Check attributes
     2032        // ------------------------------------------------------------------
     2033        unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_AttributeGroupGlobal
     2034                                                                          : GeneralAttributeCheck::E_AttributeGroupRef;
     2035
     2036        fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList);
     2037
     2038        // ------------------------------------------------------------------
     2039        // Handle "ref="
     2040        // ------------------------------------------------------------------
     2041        XercesAttGroupInfo* attGroupInfo;
     2042        Janitor<XercesAttGroupInfo> janAttGroupInfo(0);
     2043        if (!topLevel)
     2044        {
     2045                if (refEmpty)
     2046                {
     2047                        return 0;
     2048                }
     2049                attGroupInfo = processAttributeGroupRef(elem, ref, typeInfo);
     2050        }
     2051        else
     2052        {
     2053
     2054#if 0   /* ALL VALID CHARACTER TESTING WILL BE DONE IN THE SYMBOL TABLE */
     2055                // name must be a valid NCName
     2056                if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)))
     2057                {
     2058                        reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName,
     2059                                                          SchemaSymbols::fgELT_ATTRIBUTEGROUP, name);
     2060                        return 0;
     2061                }
     2062#endif
     2063
     2064                // Check for annotations
     2065                DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true);
     2066                if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     2067                {
     2068                        fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     2069                }
     2070                Janitor<XSAnnotation> janAnnot(fAnnotation);
     2071
     2072                // Process contents of global attributeGroups
     2073                XercesAttGroupInfo* saveAttGroupInfo = fCurrentAttGroupInfo;
     2074                janAttGroupInfo.reset(new (fGrammarPoolMemoryManager) XercesAttGroupInfo
     2075                (
     2076                        fStringPool->addOrFind(name)
     2077                        , fTargetNSURI
     2078                        , fGrammarPoolMemoryManager)
     2079                );
     2080
     2081                fDeclStack->addElement(elem);
     2082                fCurrentAttGroupInfo = janAttGroupInfo.get();
     2083
     2084                for (; content !=0; content = XUtil::getNextSiblingElement(content))
     2085                {
     2086                        if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ATTRIBUTE))
     2087                        {
     2088                                traverseAttributeDecl(content, typeInfo);
     2089                        }
     2090                        else if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ATTRIBUTEGROUP))
     2091                        {
     2092                                traverseAttributeGroupDecl(content, typeInfo);
     2093                        }
     2094                        else
     2095                        {
     2096                                break;
     2097                        }
     2098                }
     2099
     2100                if (content != 0)
     2101                {
     2102                        if (XMLString::equals(content->getLocalName(), SchemaSymbols::fgELT_ANYATTRIBUTE))
     2103                        {
     2104                                SchemaAttDef* anyAtt = traverseAnyAttribute(content);
     2105                                if (anyAtt)
     2106                                {
     2107                                        fCurrentAttGroupInfo->addAnyAttDef(anyAtt);
     2108                                }
     2109                                if (XUtil::getNextSiblingElement(content) != 0)
     2110                                {
     2111                                        reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AttGroupContentError, name);
     2112                                }
     2113                        }
     2114                        else
     2115                        {
     2116                                reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AttGroupContentError, name);
     2117                        }
     2118                }
     2119
     2120                // Pop declaration
     2121                fDeclStack->removeElementAt(fDeclStack->size() - 1);
     2122
     2123                fAttGroupRegistry->put((void*) fStringPool->getValueForId(fStringPool->addOrFind(name)), janAttGroupInfo.get());
     2124                // Restore old attGroupInfo
     2125                attGroupInfo = janAttGroupInfo.release();
     2126                fCurrentAttGroupInfo = saveAttGroupInfo;
     2127
     2128                // Check Attribute Derivation Restriction OK
     2129                fBuffer.set(fTargetNSURIString);
     2130                fBuffer.append(chComma);
     2131                fBuffer.append(name);
     2132
     2133                unsigned int nameIndex = fStringPool->addOrFind(fBuffer.getRawBuffer());
     2134
     2135                if (fRedefineComponents && fRedefineComponents->get(SchemaSymbols::fgELT_ATTRIBUTEGROUP, nameIndex)) {
     2136
     2137                        fBuffer.set(name);
     2138                        fBuffer.append(SchemaSymbols::fgRedefIdentifier);
     2139                        XercesAttGroupInfo* baseAttGroupInfo = fAttGroupRegistry->get(fBuffer.getRawBuffer());
     2140
     2141                        if (baseAttGroupInfo)
     2142                                checkAttDerivationOK(elem, baseAttGroupInfo, attGroupInfo);
     2143                }
     2144
     2145                // Store annotation
     2146                if (!janAnnot.isDataNull())
     2147                        fSchemaGrammar->putAnnotation(attGroupInfo, janAnnot.release());
     2148        }
     2149
     2150        // calculate complete wildcard if necessary
     2151        if (attGroupInfo)
     2152        {
     2153                XMLSize_t anyAttCount = attGroupInfo->anyAttributeCount();
     2154                if (anyAttCount && !attGroupInfo->getCompleteWildCard())
     2155                {
     2156                        SchemaAttDef* attGroupWildCard =  new (fGrammarPoolMemoryManager)
     2157                                SchemaAttDef(attGroupInfo->anyAttributeAt(0));
     2158
     2159                        for (XMLSize_t k= 1; k < anyAttCount; k++)
     2160                                attWildCardIntersection(attGroupWildCard, attGroupInfo->anyAttributeAt(k));
     2161
     2162                        attGroupInfo->setCompleteWildCard(attGroupWildCard);
     2163                }
     2164        }
     2165
     2166        return attGroupInfo;
    19102167}
    19112168
     
    19132170inline XercesAttGroupInfo*
    19142171TraverseSchema::traverseAttributeGroupDeclNS(const DOMElement* const elem,
    1915                                              const XMLCh* const uriStr,
    1916                                              const XMLCh* const name) {
    1917 
    1918     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    1919 
    1920     // ------------------------------------------------------------------
    1921     // Get grammar information
    1922     // ------------------------------------------------------------------
    1923     Grammar* aGrammar = fGrammarResolver->getGrammar(uriStr);
    1924 
    1925     if (!aGrammar || aGrammar->getGrammarType() != Grammar::SchemaGrammarType) {
    1926 
    1927         reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, uriStr);
    1928         return 0;
    1929     }
    1930 
    1931     XercesAttGroupInfo* attGroupInfo = ((SchemaGrammar*)aGrammar)->getAttGroupInfoRegistry()->get(name);
    1932 
    1933     return attGroupInfo;
     2172                                                                                         const XMLCh* const uriStr,
     2173                                                                                         const XMLCh* const name)
     2174{
     2175        DEBUG_SCHEMA_MESSAGE
     2176        (
     2177                "TraverseSchema::traverseAttributeGroupDeclNS("
     2178                << elem
     2179                << ',' << uriStr
     2180                << ',' << name
     2181                << ')'
     2182        );
     2183
     2184
     2185        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     2186
     2187        // ------------------------------------------------------------------
     2188        // Get grammar information
     2189        // ------------------------------------------------------------------
     2190        Grammar* aGrammar = fGrammarResolver->getGrammar(uriStr);
     2191
     2192        if (!aGrammar || aGrammar->getGrammarType() != Grammar::SchemaGrammarType) {
     2193
     2194                reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::GrammarNotFound, uriStr);
     2195                return 0;
     2196        }
     2197
     2198        XercesAttGroupInfo* attGroupInfo = ((SchemaGrammar*)aGrammar)->getAttGroupInfoRegistry()->get(name);
     2199
     2200        return attGroupInfo;
    19342201}
    19352202
     
    19492216  */
    19502217ContentSpecNode*
    1951 TraverseSchema::traverseAny(const DOMElement* const elem) {
    1952 
    1953     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    1954 
    1955     // -----------------------------------------------------------------------
    1956     // Check Attributes
    1957     // -----------------------------------------------------------------------
    1958     fAttributeCheck.checkAttributes(
    1959         elem, GeneralAttributeCheck::E_Any, this, false, fNonXSAttList
    1960     );
    1961 
    1962     // ------------------------------------------------------------------
    1963     // First, handle any ANNOTATION declaration
    1964     // ------------------------------------------------------------------
    1965     if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0)
    1966         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected);
    1967     if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    1968     {
    1969         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    1970     }
    1971     Janitor<XSAnnotation> janAnnot(fAnnotation);
    1972 
    1973     // ------------------------------------------------------------------
    1974     // Get attributes
    1975     // ------------------------------------------------------------------
    1976     const XMLCh* const processContents = getElementAttValue(elem, SchemaSymbols::fgATT_PROCESSCONTENTS);
    1977     const XMLCh* const nameSpace = getElementAttValue(elem, SchemaSymbols::fgATT_NAMESPACE);
    1978 
    1979     // ------------------------------------------------------------------
    1980     // Set default node type based on 'processContents' value
    1981     // ------------------------------------------------------------------
    1982     ContentSpecNode::NodeTypes anyType = ContentSpecNode::Any;
    1983     ContentSpecNode::NodeTypes anyLocalType = ContentSpecNode::Any_NS;
    1984     ContentSpecNode::NodeTypes anyOtherType = ContentSpecNode::Any_Other;
    1985 
    1986     if ((processContents && *processContents)
    1987         && !XMLString::equals(processContents, SchemaSymbols::fgATTVAL_STRICT)) {
    1988 
    1989         if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_LAX)) {
    1990 
    1991             anyType = ContentSpecNode::Any_Lax;
    1992             anyOtherType = ContentSpecNode::Any_Other_Lax;
    1993             anyLocalType = ContentSpecNode::Any_NS_Lax;
    1994         }
    1995         else if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_SKIP)) {
    1996 
    1997             anyType = ContentSpecNode::Any_Skip;
    1998             anyOtherType = ContentSpecNode::Any_Other_Skip;
    1999             anyLocalType = ContentSpecNode::Any_NS_Skip;
    2000         }
    2001     }
    2002 
    2003     // ------------------------------------------------------------------
    2004     // Process 'namespace' attribute
    2005     // ------------------------------------------------------------------
    2006     ContentSpecNode* retSpecNode = 0;
    2007 
    2008     if ((!nameSpace || !*nameSpace)
    2009         || XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDANY)) {
    2010         retSpecNode = new (fGrammarPoolMemoryManager) ContentSpecNode
    2011         (
    2012             new (fGrammarPoolMemoryManager) QName
    2013             (
    2014                 XMLUni::fgZeroLenString
    2015                 , XMLUni::fgZeroLenString
    2016                 , fEmptyNamespaceURI
    2017                 , fGrammarPoolMemoryManager
    2018             )
    2019             , false
    2020             , fGrammarPoolMemoryManager
    2021         );
    2022         retSpecNode->setType(anyType);
    2023     }
    2024     else if (XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDOTHER)) {
    2025         retSpecNode = new (fGrammarPoolMemoryManager) ContentSpecNode
    2026         (
    2027             new (fGrammarPoolMemoryManager) QName
    2028             (
    2029                 XMLUni::fgZeroLenString
    2030                 , XMLUni::fgZeroLenString
    2031                 , fTargetNSURI, fGrammarPoolMemoryManager
    2032             )
    2033             , false
    2034             , fGrammarPoolMemoryManager
    2035         );
    2036         retSpecNode->setType(anyOtherType);
    2037     }
    2038     else {
    2039 
    2040         XMLStringTokenizer nameSpaceTokens(nameSpace, fMemoryManager);
    2041         ValueVectorOf<unsigned int> uriList(8, fGrammarPoolMemoryManager);
    2042         Janitor<ContentSpecNode>    firstNode(0);
    2043         Janitor<ContentSpecNode>    secondNode(0);
    2044         DatatypeValidator* anyURIDV = fDatatypeRegistry->getDatatypeValidator(SchemaSymbols::fgDT_ANYURI);
    2045 
    2046         while (nameSpaceTokens.hasMoreTokens()) {
    2047 
    2048             const XMLCh* tokenElem = nameSpaceTokens.nextToken();
    2049             int uriIndex = fEmptyNamespaceURI;
    2050 
    2051             if (!XMLString::equals(tokenElem,SchemaSymbols::fgATTVAL_TWOPOUNDLOCAL)) { // not ##local
    2052 
    2053                 if (XMLString::equals(tokenElem,SchemaSymbols::fgATTVAL_TWOPOUNDTRAGETNAMESPACE)) {
    2054                     uriIndex = fTargetNSURI;
    2055                 }
    2056                 else {
    2057                     try {
    2058                         anyURIDV->validate(tokenElem
    2059                                          , fSchemaInfo->getValidationContext()
    2060                                          , fMemoryManager);
    2061                     }
    2062                     catch(const XMLException& excep) {
    2063                         reportSchemaError(elem, excep);
    2064                     }
    2065                     uriIndex = fURIStringPool->addOrFind(tokenElem);
    2066                 }
    2067             }
    2068 
    2069             if (uriList.containsElement(uriIndex)) {
    2070                 continue;
    2071             }
    2072 
    2073             uriList.addElement(uriIndex);
    2074 
    2075             firstNode.release();
    2076             firstNode.reset( new (fGrammarPoolMemoryManager) ContentSpecNode
    2077             (
    2078                 new (fGrammarPoolMemoryManager) QName
    2079                 (
    2080                     XMLUni::fgZeroLenString
    2081                     , XMLUni::fgZeroLenString
    2082                     , uriIndex, fGrammarPoolMemoryManager
    2083                 )
    2084                 , false
    2085                 , fGrammarPoolMemoryManager
    2086             ));
    2087             firstNode.get()->setType(anyLocalType);
    2088 
    2089             if (secondNode.get() == 0) {
    2090                 secondNode.reset(firstNode.release());
    2091             }
    2092             else {
    2093                 ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode
    2094                 (
    2095                     ContentSpecNode::Any_NS_Choice
    2096                     , secondNode.get()
    2097                     , firstNode.get()
    2098                     , true
    2099                     , true
    2100                     , fGrammarPoolMemoryManager
    2101                 );
    2102                 secondNode.release();
    2103                 secondNode.reset(newNode);
    2104                 firstNode.release();
    2105             }
    2106         }
    2107         firstNode.release();
    2108         retSpecNode = secondNode.release();
    2109     }
    2110 
    2111     // Store annotation
    2112     if (retSpecNode && !janAnnot.isDataNull())
    2113         fSchemaGrammar->putAnnotation(retSpecNode, janAnnot.release());
    2114 
    2115     return retSpecNode;
     2218TraverseSchema::traverseAny(const DOMElement* const elem)
     2219{
     2220        DEBUG_SCHEMA_MESSAGE
     2221        (
     2222                "TraverseSchema::traverseAny("
     2223                << elem
     2224                << ')'
     2225        );
     2226
     2227        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     2228
     2229        // -----------------------------------------------------------------------
     2230        // Check Attributes
     2231        // -----------------------------------------------------------------------
     2232        fAttributeCheck.checkAttributes(
     2233                elem, GeneralAttributeCheck::E_Any, this, false, fNonXSAttList
     2234        );
     2235
     2236        // ------------------------------------------------------------------
     2237        // First, handle any ANNOTATION declaration
     2238        // ------------------------------------------------------------------
     2239        if (checkContent(elem, XUtil::getFirstChildElement(elem), true) != 0)
     2240                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::OnlyAnnotationExpected);
     2241        if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     2242        {
     2243                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     2244        }
     2245        Janitor<XSAnnotation> janAnnot(fAnnotation);
     2246
     2247        // ------------------------------------------------------------------
     2248        // Get attributes
     2249        // ------------------------------------------------------------------
     2250        const XMLCh* const processContents = getElementAttValue(elem, SchemaSymbols::fgATT_PROCESSCONTENTS);
     2251        const XMLCh* const nameSpace = getElementAttValue(elem, SchemaSymbols::fgATT_NAMESPACE);
     2252
     2253        // ------------------------------------------------------------------
     2254        // Set default node type based on 'processContents' value
     2255        // ------------------------------------------------------------------
     2256        ContentSpecNode::NodeTypes anyType = ContentSpecNode::Any;
     2257        ContentSpecNode::NodeTypes anyLocalType = ContentSpecNode::Any_NS;
     2258        ContentSpecNode::NodeTypes anyOtherType = ContentSpecNode::Any_Other;
     2259
     2260        if ((processContents && *processContents)
     2261                && !XMLString::equals(processContents, SchemaSymbols::fgATTVAL_STRICT)) {
     2262
     2263                if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_LAX)) {
     2264
     2265                        anyType = ContentSpecNode::Any_Lax;
     2266                        anyOtherType = ContentSpecNode::Any_Other_Lax;
     2267                        anyLocalType = ContentSpecNode::Any_NS_Lax;
     2268                }
     2269                else if (XMLString::equals(processContents, SchemaSymbols::fgATTVAL_SKIP)) {
     2270
     2271                        anyType = ContentSpecNode::Any_Skip;
     2272                        anyOtherType = ContentSpecNode::Any_Other_Skip;
     2273                        anyLocalType = ContentSpecNode::Any_NS_Skip;
     2274                }
     2275        }
     2276
     2277        // ------------------------------------------------------------------
     2278        // Process 'namespace' attribute
     2279        // ------------------------------------------------------------------
     2280        ContentSpecNode* retSpecNode = 0;
     2281
     2282        if ((!nameSpace || !*nameSpace)
     2283                || XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDANY)) {
     2284                retSpecNode = new (fGrammarPoolMemoryManager) ContentSpecNode
     2285                (
     2286                        new (fGrammarPoolMemoryManager) QName
     2287                        (
     2288                                XMLUni::fgZeroLenString
     2289                                , XMLUni::fgZeroLenString
     2290                                , fEmptyNamespaceURI
     2291                                , fGrammarPoolMemoryManager
     2292                        )
     2293                        , false
     2294                        , fGrammarPoolMemoryManager
     2295                );
     2296                retSpecNode->setType(anyType);
     2297        }
     2298        else if (XMLString::equals(nameSpace, SchemaSymbols::fgATTVAL_TWOPOUNDOTHER)) {
     2299                retSpecNode = new (fGrammarPoolMemoryManager) ContentSpecNode
     2300                (
     2301                        new (fGrammarPoolMemoryManager) QName
     2302                        (
     2303                                XMLUni::fgZeroLenString
     2304                                , XMLUni::fgZeroLenString
     2305                                , fTargetNSURI, fGrammarPoolMemoryManager
     2306                        )
     2307                        , false
     2308                        , fGrammarPoolMemoryManager
     2309                );
     2310                retSpecNode->setType(anyOtherType);
     2311        }
     2312        else
     2313        {
     2314                XMLStringTokenizer nameSpaceTokens(nameSpace, fMemoryManager);
     2315                ValueVectorOf<unsigned int> uriList(8, fGrammarPoolMemoryManager);
     2316                Janitor<ContentSpecNode>    firstNode(0);
     2317                Janitor<ContentSpecNode>    secondNode(0);
     2318                DatatypeValidator* anyURIDV = fDatatypeRegistry->getDatatypeValidator(SchemaSymbols::fgDT_ANYURI);
     2319
     2320                while (nameSpaceTokens.hasMoreTokens())
     2321                {
     2322                        const XMLCh* tokenElem = nameSpaceTokens.nextToken();
     2323                        int uriIndex = fEmptyNamespaceURI;
     2324
     2325                        if (!XMLString::equals(tokenElem,SchemaSymbols::fgATTVAL_TWOPOUNDLOCAL))
     2326                        { // not ##local
     2327                                if (XMLString::equals(tokenElem,SchemaSymbols::fgATTVAL_TWOPOUNDTRAGETNAMESPACE))
     2328                                {
     2329                                        uriIndex = fTargetNSURI;
     2330                                }
     2331                                else
     2332                                {
     2333                                        try
     2334                                        {
     2335                                                anyURIDV->validate(tokenElem
     2336                                                                                 , fSchemaInfo->getValidationContext()
     2337                                                                                 , fMemoryManager);
     2338                                        }
     2339                                        catch(const XMLException& excep)
     2340                                        {
     2341                                                reportSchemaError(elem, excep);
     2342                                        }
     2343
     2344                                        uriIndex = RESOLVE_URI_ID(tokenElem);
     2345                                }
     2346                        }
     2347
     2348                        if (uriList.containsElement(uriIndex))
     2349                        {
     2350                                continue;
     2351                        }
     2352
     2353                        uriList.addElement(uriIndex);
     2354
     2355                        firstNode.release();
     2356                        firstNode.reset( new (fGrammarPoolMemoryManager) ContentSpecNode
     2357                        (
     2358                                new (fGrammarPoolMemoryManager) QName
     2359                                (
     2360                                        XMLUni::fgZeroLenString
     2361                                        , XMLUni::fgZeroLenString
     2362                                        , uriIndex, fGrammarPoolMemoryManager
     2363                                )
     2364                                , false
     2365                                , fGrammarPoolMemoryManager
     2366                        ));
     2367                        firstNode.get()->setType(anyLocalType);
     2368
     2369                        if (secondNode.get() == 0) {
     2370                                secondNode.reset(firstNode.release());
     2371                        }
     2372                        else {
     2373                                ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode
     2374                                (
     2375                                        ContentSpecNode::Any_NS_Choice
     2376                                        , secondNode.get()
     2377                                        , firstNode.get()
     2378                                        , true
     2379                                        , true
     2380                                        , fGrammarPoolMemoryManager
     2381                                );
     2382                                secondNode.release();
     2383                                secondNode.reset(newNode);
     2384                                firstNode.release();
     2385                        }
     2386                }
     2387                firstNode.release();
     2388                retSpecNode = secondNode.release();
     2389        }
     2390
     2391        // Store annotation
     2392        if (retSpecNode && !janAnnot.isDataNull())
     2393                fSchemaGrammar->putAnnotation(retSpecNode, janAnnot.release());
     2394
     2395        return retSpecNode;
    21162396}
    21172397
     
    21292409  */
    21302410ContentSpecNode*
    2131 TraverseSchema::traverseAll(const DOMElement* const elem, bool& hasChildren) {
    2132 
    2133     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    2134     hasChildren = false;
    2135 
    2136     // -----------------------------------------------------------------------
    2137     // Check attributes
    2138     // -----------------------------------------------------------------------
    2139     fAttributeCheck.checkAttributes(
    2140         elem, GeneralAttributeCheck::E_All, this, false, fNonXSAttList
    2141     );
    2142 
    2143     // -----------------------------------------------------------------------
    2144     // Process contents
    2145     // -----------------------------------------------------------------------
    2146     DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true);
    2147     if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    2148     {
    2149         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    2150     }
    2151     Janitor<XSAnnotation> janAnnot(fAnnotation);
    2152 
    2153     if (child == 0) {
    2154         return 0;
    2155     }
    2156 
    2157     Janitor<ContentSpecNode>    left(0);
    2158     Janitor<ContentSpecNode>    right(0);
    2159     Janitor<ContentSpecNode>     contentSpecNode(0);
    2160     bool hadContent = false;
    2161 
    2162     for (; child != 0; child = XUtil::getNextSiblingElement(child)) {
    2163         hasChildren = true;
    2164         contentSpecNode.release();
    2165         const XMLCh* childName = child->getLocalName();
    2166 
    2167         if (XMLString::equals(childName, SchemaSymbols::fgELT_ELEMENT)) {
    2168 
    2169             SchemaElementDecl* elemDecl = traverseElementDecl(child);
    2170 
    2171             if (!elemDecl)
    2172                 continue;
    2173 
    2174             contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode
    2175             (
    2176                 elemDecl
    2177                 , fGrammarPoolMemoryManager
    2178             ));
    2179             checkMinMax(contentSpecNode.get(), child, All_Element);
    2180         }
    2181         else {
    2182 
    2183             reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AllContentError, childName);
    2184             continue;
    2185         }
    2186 
    2187         hadContent = true;
    2188 
    2189         if (!left.get()) {
    2190             left.reset(contentSpecNode.release());
    2191         }
    2192         else if (!right.get()) {
    2193             right.reset(contentSpecNode.release());
    2194         }
    2195         else {
    2196             ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode
    2197             (
    2198                 ContentSpecNode::All
    2199                 , left.get()
    2200                 , right.get()
    2201                 , true
    2202                 , true
    2203                 , fGrammarPoolMemoryManager
    2204             );
    2205             left.release();
    2206             left.reset(newNode);
    2207             right.release();
    2208             right.reset(contentSpecNode.release());
    2209         }
    2210     }
    2211     contentSpecNode.release();
    2212 
    2213     if (hadContent) {
    2214         ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode
    2215         (
    2216             ContentSpecNode::All
    2217             , left.get()
    2218             , right.get()
    2219             , true
    2220             , true
    2221             , fGrammarPoolMemoryManager
    2222         );
    2223 
    2224         left.release();
    2225         left.reset(newNode);
    2226 
    2227         if (!janAnnot.isDataNull())
    2228             fSchemaGrammar->putAnnotation(left.get(), janAnnot.release());
    2229     }
    2230     right.release();
    2231     return left.release();
     2411TraverseSchema::traverseAll(const DOMElement* const elem, bool& hasChildren)
     2412{
     2413        DEBUG_SCHEMA_MESSAGE
     2414        (
     2415                "TraverseSchema::traverseAll("
     2416                << elem
     2417                << ')'
     2418        );
     2419
     2420        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     2421        hasChildren = false;
     2422
     2423        // -----------------------------------------------------------------------
     2424        // Check attributes
     2425        // -----------------------------------------------------------------------
     2426        fAttributeCheck.checkAttributes(
     2427                elem, GeneralAttributeCheck::E_All, this, false, fNonXSAttList
     2428        );
     2429
     2430        // -----------------------------------------------------------------------
     2431        // Process contents
     2432        // -----------------------------------------------------------------------
     2433        DOMElement* child = checkContent(elem, XUtil::getFirstChildElement(elem), true);
     2434        if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     2435        {
     2436                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     2437        }
     2438        Janitor<XSAnnotation> janAnnot(fAnnotation);
     2439
     2440        if (child == 0) {
     2441                return 0;
     2442        }
     2443
     2444        Janitor<ContentSpecNode>    left(0);
     2445        Janitor<ContentSpecNode>    right(0);
     2446        Janitor<ContentSpecNode>     contentSpecNode(0);
     2447        bool hadContent = false;
     2448
     2449        for (; child != 0; child = XUtil::getNextSiblingElement(child)) {
     2450                hasChildren = true;
     2451                contentSpecNode.release();
     2452                const XMLCh* childName = child->getLocalName();
     2453
     2454                if (XMLString::equals(childName, SchemaSymbols::fgELT_ELEMENT)) {
     2455
     2456                        SchemaElementDecl* elemDecl = traverseElementDecl(child);
     2457
     2458                        if (!elemDecl)
     2459                                continue;
     2460
     2461                        contentSpecNode.reset(new (fGrammarPoolMemoryManager) ContentSpecNode
     2462                        (
     2463                                elemDecl
     2464                                , fGrammarPoolMemoryManager
     2465                        ));
     2466                        checkMinMax(contentSpecNode.get(), child, All_Element);
     2467                }
     2468                else {
     2469
     2470                        reportSchemaError(child, XMLUni::fgXMLErrDomain, XMLErrs::AllContentError, childName);
     2471                        continue;
     2472                }
     2473
     2474                hadContent = true;
     2475
     2476                if (!left.get()) {
     2477                        left.reset(contentSpecNode.release());
     2478                }
     2479                else if (!right.get()) {
     2480                        right.reset(contentSpecNode.release());
     2481                }
     2482                else {
     2483                        ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode
     2484                        (
     2485                                ContentSpecNode::All
     2486                                , left.get()
     2487                                , right.get()
     2488                                , true
     2489                                , true
     2490                                , fGrammarPoolMemoryManager
     2491                        );
     2492                        left.release();
     2493                        left.reset(newNode);
     2494                        right.release();
     2495                        right.reset(contentSpecNode.release());
     2496                }
     2497        }
     2498        contentSpecNode.release();
     2499
     2500        if (hadContent) {
     2501                ContentSpecNode* newNode = new (fGrammarPoolMemoryManager) ContentSpecNode
     2502                (
     2503                        ContentSpecNode::All
     2504                        , left.get()
     2505                        , right.get()
     2506                        , true
     2507                        , true
     2508                        , fGrammarPoolMemoryManager
     2509                );
     2510
     2511                left.release();
     2512                left.reset(newNode);
     2513
     2514                if (!janAnnot.isDataNull())
     2515                        fSchemaGrammar->putAnnotation(left.get(), janAnnot.release());
     2516        }
     2517        right.release();
     2518        return left.release();
    22322519}
    22332520
     
    22552542  */
    22562543void TraverseSchema::traverseAttributeDecl(const DOMElement* const elem,
    2257                                            ComplexTypeInfo* const typeInfo,
    2258                                            const bool topLevel) {
    2259 
    2260     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    2261 
    2262     const XMLCh*   name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
    2263     const XMLCh*   ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
    2264     bool           nameEmpty = (!name || !*name);
    2265     bool           refEmpty = (!ref || !*ref);
    2266 
    2267     if (nameEmpty && refEmpty) {
    2268         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefAttribute);
    2269         return;
    2270     }
    2271 
    2272     if (topLevel && nameEmpty) {
    2273 
    2274         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelNoNameAttribute);
    2275         return;
    2276     }
    2277 
    2278     // ------------------------------------------------------------------
    2279     // Check attributes
    2280     // ------------------------------------------------------------------
    2281     unsigned short scope = (topLevel)
    2282         ? GeneralAttributeCheck::E_AttributeGlobal
    2283         : (refEmpty) ? GeneralAttributeCheck::E_AttributeLocal
    2284                      : GeneralAttributeCheck::E_AttributeRef;
    2285 
    2286     fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList);
    2287 
    2288     const XMLCh* defaultVal = getElementAttValue(elem, SchemaSymbols::fgATT_DEFAULT);
    2289     const XMLCh* fixedVal = getElementAttValue(elem, SchemaSymbols::fgATT_FIXED);
    2290     const XMLCh* useVal = getElementAttValue(elem, SchemaSymbols::fgATT_USE);
    2291     const XMLCh* attForm = getElementAttValue(elem, SchemaSymbols::fgATT_FORM);
    2292     const XMLCh* dvType = getElementAttValue(elem, SchemaSymbols::fgATT_TYPE, DatatypeValidator::QName);
    2293     DOMElement* simpleType = checkContent(elem, XUtil::getFirstChildElement(elem), true);
    2294     Janitor<XSAnnotation> janAnnot(fAnnotation);
    2295     bool         badContent = false;
    2296 
    2297     while (simpleType != 0) {
    2298 
    2299         const XMLCh* contentName = simpleType->getLocalName();
    2300 
    2301         if (XMLString::equals(SchemaSymbols::fgELT_SIMPLETYPE, contentName)) {
    2302 
    2303             if (XUtil::getNextSiblingElement(simpleType) != 0) {
    2304                 badContent = true;
    2305             }
    2306             break;
    2307         }
    2308 
    2309         badContent = true;
    2310         simpleType = XUtil::getNextSiblingElement(simpleType);
    2311     }
    2312 
    2313     if (badContent) {
    2314         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttributeContent,
    2315                           (name) ? name : ref);
    2316     }
    2317 
    2318     if (defaultVal) {
    2319 
    2320         if (fixedVal) {
    2321 
    2322             fixedVal = 0;
    2323             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeDefaultFixedValue,
    2324                               (name) ? name : ref);
    2325         }
    2326 
    2327         if ((useVal && *useVal)
    2328             && !XMLString::equals(useVal, SchemaSymbols::fgATTVAL_OPTIONAL)) {
    2329 
    2330             useVal = 0;
    2331             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NotOptionalDefaultAttValue,
    2332                               (name) ? name : ref);
    2333         }
    2334     }
    2335 
    2336     // processing ref
    2337     if (!refEmpty && !topLevel) {
    2338 
    2339         // Check ref representation OK - 3.2.3::3.2
    2340         if (attForm || dvType || (simpleType != 0)) {
    2341             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeRefContentError,
    2342                               (name) ? name : ref);
    2343         }
    2344 
    2345         processAttributeDeclRef(elem, typeInfo, ref, useVal, defaultVal, fixedVal);
    2346         return;
    2347     }
    2348 
    2349     if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    2350     {
    2351         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    2352         janAnnot.reset(fAnnotation);
    2353     }
    2354 
    2355     // processing 'name'
    2356     if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name))
    2357         || XMLString::equals(name, XMLUni::fgXMLNSString)) {
    2358 
    2359         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, SchemaSymbols::fgELT_ATTRIBUTE, name);
    2360         return;
    2361     }
    2362 
    2363     // Check for duplicate declaration
    2364     const XMLCh* qualified = SchemaSymbols::fgATTVAL_QUALIFIED;
    2365     int uriIndex = fEmptyNamespaceURI;
    2366 
    2367     if ((fTargetNSURIString && *fTargetNSURIString)
    2368         && (topLevel || XMLString::equals(attForm, qualified)
    2369             || ((fSchemaInfo->getElemAttrDefaultQualified() & Attr_Def_Qualified)
    2370                 && (!attForm || !*attForm)))) {
    2371         uriIndex = fTargetNSURI;
    2372     }
    2373 
    2374     // make sure that attribute namespace is not xsi uri
    2375     if (XMLString::equals(fTargetNSURIString, SchemaSymbols::fgURI_XSI)) {
    2376 
    2377         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttTNS, name);
    2378         return;
    2379     }
    2380 
    2381     if (typeInfo && typeInfo->getAttDef(name, uriIndex) != 0) {
    2382 
    2383         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, name);
    2384         return;
    2385     }
    2386     else if (fCurrentAttGroupInfo && fCurrentAttGroupInfo->containsAttribute(name, uriIndex)) {
    2387 
    2388         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, name);
    2389         return;
    2390     }
    2391 
    2392     DatatypeValidator*  dv = 0;
    2393     XMLAttDef::AttTypes attType = XMLAttDef::Simple;
    2394     SchemaInfo* saveInfo = fSchemaInfo;
    2395 
    2396     if (simpleType != 0) {
    2397 
    2398         if (dvType && *dvType) {
    2399             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeWithTypeAndSimpleType, name);
    2400         }
    2401 
    2402         dv = traverseSimpleTypeDecl(simpleType, false);
    2403     }
    2404     else if (!dvType || !*dvType) {
    2405         dv = fDatatypeRegistry->getDatatypeValidator(SchemaSymbols::fgDT_ANYSIMPLETYPE);
    2406     }
    2407     else {
    2408 
    2409         checkEnumerationRequiredNotation(elem, name, dvType);
    2410 
    2411         const XMLCh* localPart = getLocalPart(dvType);
    2412         const XMLCh* prefix = getPrefix(dvType);
    2413         const XMLCh* typeURI = resolvePrefixToURI(elem, prefix);
    2414         DatatypeValidator*  dvBack = 0;
    2415 
    2416         if (XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) {
    2417             dv = fDatatypeRegistry->getDatatypeValidator(localPart);
    2418             dvBack = dv;
    2419         }
    2420         else { //isn't of the schema for schemas namespace...
    2421 
    2422             dv = getAttrDatatypeValidatorNS(elem, localPart, typeURI);
    2423             dvBack = dv;
    2424 
    2425             while(dv != 0 && !XMLString::equals(dv->getTypeUri(), SchemaSymbols::fgURI_SCHEMAFORSCHEMA)) {
    2426                 dv = dv->getBaseValidator();
    2427             }
    2428 
    2429             if(dv)
    2430                 localPart = dv->getTypeLocalName();
    2431         }
    2432 
    2433         if(dv) {
    2434             if (XMLString::equals(localPart,XMLUni::fgIDString)) {
    2435                 attType = XMLAttDef::ID;
    2436             }
    2437             else if (XMLString::equals(localPart,XMLUni::fgIDRefString)) {
    2438                 attType = XMLAttDef::IDRef;
    2439             }
    2440             else if (XMLString::equals(localPart,XMLUni::fgIDRefsString)) {
    2441                 attType = XMLAttDef::IDRefs;
    2442             }
    2443             else if (XMLString::equals(localPart,XMLUni::fgEntityString)) {
    2444                 attType = XMLAttDef::Entity;
    2445             }
    2446             else if (XMLString::equals(localPart,XMLUni::fgEntitiesString)) {
    2447                 attType = XMLAttDef::Entities;
    2448             }
    2449             else if (XMLString::equals(localPart,XMLUni::fgNmTokenString)) {
    2450                 attType = XMLAttDef::NmToken;
    2451             }
    2452             else if (XMLString::equals(localPart,XMLUni::fgNmTokensString)) {
    2453                 attType = XMLAttDef::NmTokens;
    2454             }
    2455             else if (XMLString::equals(localPart,XMLUni::fgNotationString)) {
    2456                 attType = XMLAttDef::Notation;
    2457             }
    2458             else {
    2459                 attType = XMLAttDef::Simple;
    2460             }
    2461         }
    2462         else
    2463             attType = XMLAttDef::Simple;
    2464 
    2465         dv = dvBack;
    2466 
    2467         if (!dv) {
    2468             reportSchemaError
    2469             (
    2470                 elem
    2471                 , XMLUni::fgXMLErrDomain
    2472                 , XMLErrs::AttributeSimpleTypeNotFound
    2473                 , typeURI
    2474                 , localPart
    2475                 , name
    2476             );
    2477         }
    2478     }
    2479 
    2480     // restore schema information, if necessary
    2481     fSchemaInfo = saveInfo;
    2482 
    2483     bool required = false;
    2484     bool prohibited = false;
    2485 
    2486     if (useVal && *useVal) {
    2487 
    2488         if (XMLString::equals(useVal, SchemaSymbols::fgATTVAL_REQUIRED)) {
    2489             required = true;
    2490         }
    2491         else if (XMLString::equals(useVal, SchemaSymbols::fgATTVAL_PROHIBITED)) {
    2492             prohibited = true;
    2493         }
    2494     }
    2495 
    2496     // validate fixed/default values
    2497     const XMLCh* valueToCheck = defaultVal ? defaultVal : fixedVal;
    2498     bool  ofTypeID = (dv && dv->getType() == DatatypeValidator::ID);
    2499 
    2500     if (attType == XMLAttDef::Simple && dv && valueToCheck) {
    2501 
    2502         short wsFacet = dv->getWSFacet();
    2503         if((wsFacet == DatatypeValidator::REPLACE && !XMLString::isWSReplaced(valueToCheck)) ||
    2504            (wsFacet == DatatypeValidator::COLLAPSE && !XMLString::isWSCollapsed(valueToCheck)))
    2505         {
    2506             XMLCh* normalizedValue=XMLString::replicate(valueToCheck, fMemoryManager);
    2507             ArrayJanitor<XMLCh> tempURIName(normalizedValue, fMemoryManager);
    2508             if(wsFacet == DatatypeValidator::REPLACE)
    2509                 XMLString::replaceWS(normalizedValue, fMemoryManager);
    2510             else if(wsFacet == DatatypeValidator::COLLAPSE)
    2511                 XMLString::collapseWS(normalizedValue, fMemoryManager);
    2512             valueToCheck=fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue));
    2513         }
    2514         try {
    2515             dv->validate(valueToCheck
    2516                       , fSchemaInfo->getValidationContext()
    2517                       , fMemoryManager);
    2518         }
    2519         catch (const XMLException& excep) {
    2520             reportSchemaError(elem, excep);
    2521         }
    2522         catch(const OutOfMemoryException&)
    2523         {
    2524             throw;
    2525         }
    2526         catch(...) {
    2527             reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::DatatypeValidationFailure, valueToCheck);
    2528         }
    2529     }
    2530     else if((attType == XMLAttDef::NmTokens || attType==XMLAttDef::IDRefs || attType==XMLAttDef::Entities) &&
    2531             valueToCheck && !XMLString::isWSCollapsed(valueToCheck))
    2532     {
    2533         XMLCh* normalizedValue=XMLString::replicate(valueToCheck, fMemoryManager);
    2534         ArrayJanitor<XMLCh> tempURIName(normalizedValue, fMemoryManager);
    2535         XMLString::collapseWS(normalizedValue, fMemoryManager);
    2536         valueToCheck=fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue));
    2537     }
    2538 
    2539     if (ofTypeID && valueToCheck) {
    2540         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect3, name);
    2541     }
    2542 
    2543     // check for multiple attributes with type derived from ID
    2544     if (!topLevel && ofTypeID) {
    2545 
    2546         if (fCurrentAttGroupInfo) {
    2547 
    2548             if (fCurrentAttGroupInfo->containsTypeWithId()) {
    2549 
    2550                 reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttGrpPropCorrect3, name);
    2551                 return;
    2552             }
    2553 
    2554             fCurrentAttGroupInfo->setTypeWithId(true);
    2555         }
    2556         else {
    2557 
    2558             if (typeInfo->containsAttWithTypeId()) {
    2559 
    2560                 reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect5, name);
    2561                 return;
    2562             }
    2563 
    2564             typeInfo->setAttWithTypeId(true);
    2565         }
    2566     }
    2567 
    2568     // create SchemaAttDef
    2569     SchemaAttDef* attDef = new (fGrammarPoolMemoryManager) SchemaAttDef
    2570     (
    2571         XMLUni::fgZeroLenString
    2572         , name
    2573         , uriIndex
    2574         , attType
    2575         , XMLAttDef::Implied
    2576         , fGrammarPoolMemoryManager
    2577     );
    2578 
    2579     attDef->setDatatypeValidator(dv);
    2580 
    2581     if (prohibited) {
    2582         attDef->setDefaultType(XMLAttDef::Prohibited);
    2583     }
    2584     else if (required) {
    2585 
    2586         if (fixedVal) {
    2587             attDef->setDefaultType(XMLAttDef::Required_And_Fixed);
    2588         }
    2589         else {
    2590             attDef->setDefaultType(XMLAttDef::Required);
    2591         }
    2592     }
    2593     else {
    2594 
    2595         if (fixedVal) {
    2596             attDef->setDefaultType(XMLAttDef::Fixed);
    2597         }
    2598         else if (defaultVal) {
    2599             attDef->setDefaultType(XMLAttDef::Default);
    2600         }
    2601     }
    2602 
    2603     if (valueToCheck) {
    2604         attDef->setValue(valueToCheck);
    2605     }
    2606 
    2607     if (!janAnnot.isDataNull())
    2608         fSchemaGrammar->putAnnotation(attDef, janAnnot.release());
    2609 
    2610     if (topLevel)
    2611     {
    2612         fAttributeDeclRegistry->put((void*) fStringPool->getValueForId(fStringPool->addOrFind(name)), attDef);
    2613         attDef->setPSVIScope(PSVIDefs::SCP_GLOBAL);
    2614     }
    2615     else
    2616     {
    2617         if (typeInfo)
    2618         {
    2619             typeInfo->addAttDef(attDef);
    2620             if (!fCurrentAttGroupInfo)
    2621                 attDef->setPSVIScope(PSVIDefs::SCP_LOCAL);
    2622         }
    2623 
    2624         if (fCurrentAttGroupInfo) {
    2625             fCurrentAttGroupInfo->addAttDef(attDef, (typeInfo != 0));
    2626         }
    2627     }
     2544                                                                                   ComplexTypeInfo* const typeInfo,
     2545                                                                                   const bool topLevel)
     2546{
     2547        DEBUG_SCHEMA_MESSAGE
     2548        (
     2549                "TraverseSchema::traverseAttributeDecl("
     2550                << elem
     2551                << ',' << typeInfo
     2552                << ',' << topLevel
     2553                << ')'
     2554        );
     2555
     2556        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     2557
     2558        const XMLCh*   name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
     2559        const XMLCh*   ref = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
     2560        bool           nameEmpty = (!name || !*name);
     2561        bool           refEmpty = (!ref || !*ref);
     2562
     2563        if (nameEmpty && refEmpty)
     2564        {
     2565                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefAttribute);
     2566                return;
     2567        }
     2568
     2569        if (topLevel && nameEmpty)
     2570        {
     2571                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::TopLevelNoNameAttribute);
     2572                return;
     2573        }
     2574
     2575        // ------------------------------------------------------------------
     2576        // Check attributes
     2577        // ------------------------------------------------------------------
     2578        unsigned short scope = (topLevel)
     2579                ? GeneralAttributeCheck::E_AttributeGlobal
     2580                : (refEmpty) ? GeneralAttributeCheck::E_AttributeLocal
     2581                                         : GeneralAttributeCheck::E_AttributeRef;
     2582
     2583        fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList);
     2584
     2585        const XMLCh* defaultVal = getElementAttValue(elem, SchemaSymbols::fgATT_DEFAULT);
     2586
     2587        const XMLCh* fixedVal = getElementAttValue(elem, SchemaSymbols::fgATT_FIXED);
     2588
     2589        const XMLCh* useVal = getElementAttValue(elem, SchemaSymbols::fgATT_USE);
     2590
     2591        const XMLCh* attForm = getElementAttValue(elem, SchemaSymbols::fgATT_FORM);
     2592
     2593        const XMLCh* dvType = getElementAttValue(elem, SchemaSymbols::fgATT_TYPE, DatatypeValidator::QName);
     2594
     2595        DOMElement* simpleType = checkContent(elem, XUtil::getFirstChildElement(elem), true);
     2596
     2597        Janitor<XSAnnotation> janAnnot(fAnnotation);
     2598        bool         badContent = false;
     2599
     2600        while (simpleType != 0)
     2601        {
     2602                const XMLCh* contentName = simpleType->getLocalName();
     2603
     2604                if (XMLString::equals(SchemaSymbols::fgELT_SIMPLETYPE, contentName))
     2605                {
     2606                        if (XUtil::getNextSiblingElement(simpleType) != 0)
     2607                        {
     2608                                badContent = true;
     2609                        }
     2610                        break;
     2611                }
     2612
     2613                badContent = true;
     2614                simpleType = XUtil::getNextSiblingElement(simpleType);
     2615        }
     2616
     2617        if (badContent)
     2618        {
     2619                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttributeContent, (name) ? name : ref);
     2620        }
     2621
     2622        if (defaultVal)
     2623        {
     2624                if (fixedVal)
     2625                {
     2626                        fixedVal = 0;
     2627                        reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeDefaultFixedValue,
     2628                                                          (name) ? name : ref);
     2629                }
     2630
     2631                if ((useVal && *useVal) && !XMLString::equals(useVal, SchemaSymbols::fgATTVAL_OPTIONAL))
     2632                {
     2633                        useVal = 0;
     2634                        reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NotOptionalDefaultAttValue,
     2635                                                          (name) ? name : ref);
     2636                }
     2637        }
     2638
     2639        // processing ref
     2640        if (!refEmpty && !topLevel)
     2641        {
     2642                // Check ref representation OK - 3.2.3::3.2
     2643                if (attForm || dvType || (simpleType != 0))
     2644                {
     2645                        reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeRefContentError, (name) ? name : ref);
     2646                }
     2647
     2648                processAttributeDeclRef(elem, typeInfo, ref, useVal, defaultVal, fixedVal);
     2649                return;
     2650        }
     2651
     2652        if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
     2653        {
     2654                fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
     2655                janAnnot.reset(fAnnotation);
     2656        }
     2657
     2658        // processing 'name'
     2659        if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)) || XMLString::equals(name, XMLUni::fgXMLNSString))
     2660        {
     2661                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidDeclarationName, SchemaSymbols::fgELT_ATTRIBUTE, name);
     2662                return;
     2663        }
     2664
     2665        // Check for duplicate declaration
     2666        const XMLCh* qualified = SchemaSymbols::fgATTVAL_QUALIFIED;
     2667        int uriIndex = fEmptyNamespaceURI;
     2668
     2669        if ((fTargetNSURIString && *fTargetNSURIString)
     2670                && (topLevel || XMLString::equals(attForm, qualified)
     2671                        || ((fSchemaInfo->getElemAttrDefaultQualified() & Attr_Def_Qualified)
     2672                                && (!attForm || !*attForm))))
     2673        {
     2674                uriIndex = fTargetNSURI;
     2675        }
     2676
     2677        // make sure that attribute namespace is not xsi uri
     2678        if (XMLString::equals(fTargetNSURIString, SchemaSymbols::fgURI_XSI))
     2679        {
     2680                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::InvalidAttTNS, name);
     2681                return;
     2682        }
     2683
     2684        if (typeInfo && typeInfo->getAttDef(name, uriIndex) != 0)
     2685        {
     2686                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, name);
     2687                return;
     2688        }
     2689        else if (fCurrentAttGroupInfo && fCurrentAttGroupInfo->containsAttribute(name, uriIndex))
     2690        {
     2691                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateAttribute, name);
     2692                return;
     2693        }
     2694
     2695        DatatypeValidator*  dv = 0;
     2696        XMLAttDef::AttTypes attType = XMLAttDef::Simple;
     2697        SchemaInfo* saveInfo = fSchemaInfo;
     2698
     2699        if (simpleType != 0)
     2700        {
     2701                if (dvType && *dvType)
     2702                {
     2703                        reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttributeWithTypeAndSimpleType, name);
     2704                }
     2705
     2706                dv = traverseSimpleTypeDecl(simpleType, false);
     2707        }
     2708        else if (!dvType || !*dvType)
     2709        {
     2710                dv = fDatatypeRegistry->getDatatypeValidator(SchemaSymbols::fgDT_ANYSIMPLETYPE);
     2711        }
     2712        else
     2713        {
     2714
     2715                checkEnumerationRequiredNotation(elem, name, dvType);
     2716
     2717                const XMLCh* localPart = getLocalPart(dvType);
     2718
     2719                const XMLCh* prefix = getPrefix(dvType);
     2720
     2721                const XMLCh* typeURI = resolvePrefixToURI(elem, prefix);
     2722
     2723                DatatypeValidator*  originalDv = 0;
     2724
     2725                if (XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA))
     2726                {
     2727                        dv = fDatatypeRegistry->getDatatypeValidator(localPart);
     2728                        originalDv = dv;
     2729                }
     2730                else
     2731                {
     2732                        //isn't of the schema for schemas namespace...
     2733
     2734                        dv = getAttrDatatypeValidatorNS(elem, localPart, typeURI);
     2735                        originalDv = dv;
     2736
     2737                        while (dv != 0 && !XMLString::equals(dv->getTypeUri(), SchemaSymbols::fgURI_SCHEMAFORSCHEMA))
     2738                        {
     2739                                dv = dv->getBaseValidator();
     2740                        }
     2741
     2742                        if (dv)
     2743                                localPart = dv->getTypeLocalName();
     2744                }
     2745
     2746                if (dv)
     2747                {
     2748                        if (XMLString::equals(localPart,XMLUni::fgIDString))
     2749                        {
     2750                                attType = XMLAttDef::ID;
     2751                        }
     2752                        else if (XMLString::equals(localPart,XMLUni::fgIDRefString))
     2753                        {
     2754                                attType = XMLAttDef::IDRef;
     2755                        }
     2756                        else if (XMLString::equals(localPart,XMLUni::fgIDRefsString))
     2757                        {
     2758                                attType = XMLAttDef::IDRefs;
     2759                        }
     2760                        else if (XMLString::equals(localPart,XMLUni::fgEntityString))
     2761                        {
     2762                                attType = XMLAttDef::Entity;
     2763                        }
     2764                        else if (XMLString::equals(localPart,XMLUni::fgEntitiesString))
     2765                        {
     2766                                attType = XMLAttDef::Entities;
     2767                        }
     2768                        else if (XMLString::equals(localPart,XMLUni::fgNmTokenString))
     2769                        {
     2770                                attType = XMLAttDef::NmToken;
     2771                        }
     2772                        else if (XMLString::equals(localPart,XMLUni::fgNmTokensString))
     2773                        {
     2774                                attType = XMLAttDef::NmTokens;
     2775                        }
     2776                        else if (XMLString::equals(localPart,XMLUni::fgNotationString))
     2777                        {
     2778                                attType = XMLAttDef::Notation;
     2779                        }
     2780                        else
     2781                        {
     2782                                attType = XMLAttDef::Simple;
     2783                        }
     2784                }
     2785                else
     2786                {
     2787                        attType = XMLAttDef::Simple;
     2788                }
     2789
     2790                dv = originalDv;
     2791
     2792                if (!dv)
     2793                {
     2794                        reportSchemaError
     2795                        (
     2796                                elem
     2797                                , XMLUni::fgXMLErrDomain
     2798                                , XMLErrs::AttributeSimpleTypeNotFound
     2799                                , typeURI
     2800                                , localPart
     2801                                , name
     2802                        );
     2803                }
     2804        }
     2805
     2806        // restore schema information, if necessary
     2807        fSchemaInfo = saveInfo;
     2808
     2809        bool required = false;
     2810        bool prohibited = false;
     2811
     2812        if (useVal && *useVal)
     2813        {
     2814                if (XMLString::equals(useVal, SchemaSymbols::fgATTVAL_REQUIRED))
     2815                {
     2816                        required = true;
     2817                }
     2818                else if (XMLString::equals(useVal, SchemaSymbols::fgATTVAL_PROHIBITED))
     2819                {
     2820                        prohibited = true;
     2821                }
     2822        }
     2823
     2824        // validate fixed/default values
     2825        const XMLCh* valueToCheck = defaultVal ? defaultVal : fixedVal;
     2826        bool  ofTypeID = (dv && dv->getType() == DatatypeValidator::ID);
     2827
     2828        if (attType == XMLAttDef::Simple && dv && valueToCheck)
     2829        {
     2830                short wsFacet = dv->getWSFacet();
     2831                if((wsFacet == DatatypeValidator::REPLACE && !XMLString::isWSReplaced(valueToCheck)) ||
     2832                   (wsFacet == DatatypeValidator::COLLAPSE && !XMLString::isWSCollapsed(valueToCheck)))
     2833                {
     2834                        XMLCh* normalizedValue=XMLString::replicate(valueToCheck, fMemoryManager);
     2835                        ArrayJanitor<XMLCh> tempURIName(normalizedValue, fMemoryManager);
     2836                        if(wsFacet == DatatypeValidator::REPLACE)
     2837                                XMLString::replaceWS(normalizedValue, fMemoryManager);
     2838                        else if(wsFacet == DatatypeValidator::COLLAPSE)
     2839                                XMLString::collapseWS(normalizedValue, fMemoryManager);
     2840
     2841
     2842                        valueToCheck = fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue));
     2843                }
     2844                try
     2845                {
     2846                        dv->validate(valueToCheck
     2847                                          , fSchemaInfo->getValidationContext()
     2848                                          , fMemoryManager);
     2849                }
     2850                catch (const XMLException& excep)
     2851                {
     2852                        reportSchemaError(elem, excep);
     2853                }
     2854                catch(const OutOfMemoryException&)
     2855                {
     2856                        throw;
     2857                }
     2858                catch(...)
     2859                {
     2860                        reportSchemaError(elem, XMLUni::fgValidityDomain, XMLValid::DatatypeValidationFailure, valueToCheck);
     2861                }
     2862        }
     2863        else if((attType == XMLAttDef::NmTokens || attType==XMLAttDef::IDRefs || attType==XMLAttDef::Entities) &&
     2864                        valueToCheck && !XMLString::isWSCollapsed(valueToCheck))
     2865        {
     2866                XMLCh* normalizedValue=XMLString::replicate(valueToCheck, fMemoryManager);
     2867                ArrayJanitor<XMLCh> tempURIName(normalizedValue, fMemoryManager);
     2868                XMLString::collapseWS(normalizedValue, fMemoryManager);
     2869                valueToCheck=fStringPool->getValueForId(fStringPool->addOrFind(normalizedValue));
     2870        }
     2871
     2872        if (ofTypeID && valueToCheck)
     2873        {
     2874                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect3, name);
     2875        }
     2876
     2877        // check for multiple attributes with type derived from ID
     2878        if (!topLevel && ofTypeID)
     2879        {
     2880                if (fCurrentAttGroupInfo)
     2881                {
     2882                        if (fCurrentAttGroupInfo->containsTypeWithId())
     2883                        {
     2884                                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttGrpPropCorrect3, name);
     2885                                return;
     2886                        }
     2887
     2888                        fCurrentAttGroupInfo->setTypeWithId(true);
     2889                }
     2890                else
     2891                {
     2892                        if (typeInfo->containsAttWithTypeId())
     2893                        {
     2894                                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::AttDeclPropCorrect5, name);
     2895                                return;
     2896                        }
     2897
     2898                        typeInfo->setAttWithTypeId(true);
     2899                }
     2900        }
     2901
     2902        // create SchemaAttDef
     2903        SchemaAttDef* attDef = new (fGrammarPoolMemoryManager) SchemaAttDef
     2904        (
     2905                XMLUni::fgZeroLenString
     2906                , name
     2907                , uriIndex
     2908                , attType
     2909                , XMLAttDef::Implied
     2910                , fGrammarPoolMemoryManager
     2911        );
     2912
     2913        attDef->setDatatypeValidator(dv);
     2914
     2915        if (prohibited)
     2916        {
     2917                attDef->setDefaultType(XMLAttDef::Prohibited);
     2918        }
     2919        else if (required)
     2920        {
     2921                if (fixedVal)
     2922                {
     2923                        attDef->setDefaultType(XMLAttDef::Required_And_Fixed);
     2924                }
     2925                else
     2926                {
     2927                        attDef->setDefaultType(XMLAttDef::Required);
     2928                }
     2929        }
     2930        else
     2931        {
     2932                if (fixedVal)
     2933                {
     2934                        attDef->setDefaultType(XMLAttDef::Fixed);
     2935                }
     2936                else if (defaultVal)
     2937                {
     2938                        attDef->setDefaultType(XMLAttDef::Default);
     2939                }
     2940        }
     2941
     2942        if (valueToCheck)
     2943        {
     2944                attDef->setValue(valueToCheck);
     2945        }
     2946
     2947        if (!janAnnot.isDataNull())
     2948        {
     2949                fSchemaGrammar->putAnnotation(attDef, janAnnot.release());
     2950        }
     2951
     2952        if (topLevel)
     2953        {
     2954                name = attDef->getAttName()->getRawName();
     2955                fAttributeDeclRegistry->put((void*)name, attDef);
     2956                attDef->setPSVIScope(PSVIDefs::SCP_GLOBAL);
     2957        }
     2958        else
     2959        {
     2960                if (typeInfo)
     2961                {
     2962                        typeInfo->addAttDef(attDef);
     2963                        if (!fCurrentAttGroupInfo)
     2964                                attDef->setPSVIScope(PSVIDefs::SCP_LOCAL);
     2965                }
     2966
     2967                if (fCurrentAttGroupInfo)
     2968                {
     2969                        fCurrentAttGroupInfo->addAttDef(attDef, (typeInfo != 0));
     2970                }
     2971        }
    26282972}
    26292973
     
    26552999SchemaElementDecl*
    26563000TraverseSchema::traverseElementDecl(const DOMElement* const elem,
    2657                                     const bool topLevel)
    2658 {
    2659     NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
    2660 
    2661     // if local element and ref attribute exists
    2662     if (!topLevel)
    2663     {
    2664         const XMLCh* refName = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
    2665         if (refName)
    2666             return processElementDeclRef(elem, refName);
    2667     }
    2668 
    2669     // check for empty name
    2670     const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
    2671     if (!name || !*name)
    2672     {
    2673         reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefElement);
    2674         return 0;
    2675     }
    2676 
    2677     // make sure that name is a valid NCName
    2678     if (!XMLChar1_0::isValidNCName(name, XMLString::stringLen(name)))
    2679     {
    2680         reportSchemaError(elem, XMLUni::fgXMLErrDomain,
    2681             XMLErrs::InvalidDeclarationName, SchemaSymbols::fgELT_ELEMENT, name);
    2682         return 0;
    2683     }
    2684 
    2685     // if element already exists, just return --- revisit, it should not happen
    2686     if (topLevel)
    2687     {
    2688         SchemaElementDecl* retDecl = (SchemaElementDecl*) fSchemaGrammar->getElemDecl(fTargetNSURI, name, 0, Grammar::TOP_LEVEL_SCOPE);
    2689         if (retDecl)
    2690             return retDecl;
    2691     }
    2692 
    2693     // Check attributes
    2694     unsigned short scope = (topLevel) ? GeneralAttributeCheck::E_ElementGlobal
    2695                                       : GeneralAttributeCheck::E_ElementLocal;
    2696 
    2697     fAttributeCheck.checkAttributes(elem, scope, this, topLevel, fNonXSAttList);
    2698 
    2699     // check annotation
    2700     const DOMElement* content = checkContent(elem, XUtil::getFirstChildElement(elem), true);
    2701     // Put annotations on all elements for the situation where there is a group of
    2702     // elements and not all have annotations.
    2703     //if (fScanner->getGenerateSyntheticAnnotations() && !fAnnotation && fNonXSAttList->size())
    2704     if (!fAnnotation && fScanner->getGenerateSyntheticAnnotations())
    2705     {
    2706         fAnnotation = generateSyntheticAnnotation(elem, fNonXSAttList);
    2707     }
    2708     Janitor<XSAnnotation> janAnnot(fAnnotation);
    2709 
    2710     // Create element decl
    2711     bool isDuplicate = false;
    2712     const XMLCh* valueConstraint = 0;
    2713     SchemaElementDecl* elemDecl =
    2714         createSchemaElementDecl(elem, name, isDuplicate, valueConstraint, topLevel);
    2715 
    2716     if (!isDuplicate) {
    2717 
    2718         fSchemaGrammar->putElemDecl(elemDecl);
    2719 
    2720         if (valueConstraint)
    2721             elemDecl->setDefaultValue(valueConstraint);
    2722 
    2723         if (!janAnnot.isDataNull())
    2724             fSchemaGrammar->putAnnotation(elemDecl, janAnnot.release());
    2725 
    2726         if (fCurrentComplexType &&
    2727             elemDecl->getEnclosingScope() == fCurrentComplexType->getScopeDefined()) {
    2728             fCurrentComplexType->addElement(elemDecl);
    2729             elemDecl->setPSVIScope(PSVIDefs::SCP_LOCAL);
    2730         }
    2731 
    2732         if (fCurrentGroupInfo &&
    2733             elemDecl->getEnclosingScope() == fCurrentGroupInfo->getScope()) {
    2734             fCurrentGroupInfo->addElement(elemDecl);
    2735             elemDecl->setPSVIScope(PSVIDefs::SCP_ABSENT);
    2736         }
    2737     }
    2738     else {
    2739         if (fAnnotation) {
    2740             XSAnnotation* xsAnnot = fSchemaGrammar->getAnnotation(elemDecl);
    2741             if (!xsAnnot) {
    2742                 fSchemaGrammar->putAnnotation(elemDecl, janAnnot.release());
    2743             }
    2744             else {
    2745                 xsAnnot->setNext(janAnnot.release());
    2746             }
    2747         }
    2748     }
    2749 
    2750     // Process children
    2751     bool               anonymousType = false;
    2752     ComplexTypeInfo*   typeInfo = 0;
    2753     DatatypeValidator* validator = 0;
    2754 
    2755     if (content != 0)
    2756     {
    2757         const XMLCh* contentName = content->getLocalName();
    2758 
    2759         if (XMLString::equals(contentName, SchemaSymbols::fgELT_COMPLEXTYPE))
    2760         {
    2761             const XMLCh* temp = content->getAttribute(SchemaSymbols::fgATT_NAME);
    2762 
    2763             if (temp && *temp)
    2764             {
    2765                 // REVISIT - we are bypassing the complex type declaration.
    2766                 reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AnonComplexTypeWithName, name);
    2767             }
    2768             else
    2769             {
    2770                 typeInfo = checkForComplexTypeInfo(content);
    2771 
    2772                 if (typeInfo)
    2773                 {
    2774                     validator = typeInfo->getDatatypeValidator();
    2775 
    2776                     if (!isDuplicate) {
    2777 
    2778                         //Recursing element
    2779                         if (typeInfo->getPreprocessed()) {
    2780 
    2781                             const XMLCh* typeInfoName = typeInfo->getTypeName();
    2782                             fSchemaInfo->addRecursingType(content, typeInfoName + XMLString::indexOf(typeInfoName, chComma) + 1);
    2783                         }
    2784                     }
    2785                 }
    2786             }
    2787 
    2788             anonymousType = true;
    2789             content = XUtil::getNextSiblingElement(content);
    2790         }
    2791         else if (XMLString::equals(contentName, SchemaSymbols::fgELT_SIMPLETYPE))
    2792         {
    2793             const XMLCh* temp = content->getAttribute(SchemaSymbols::fgATT_NAME);
    2794             if (temp && *temp)
    2795                 // REVISIT - we are bypassing the simple type declaration.
    2796                 reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::AnonSimpleTypeWithName, name);
    2797             else
    2798                 validator = checkForSimpleTypeValidator(content);
    2799 
    2800             anonymousType = true;
    2801             content = XUtil::getNextSiblingElement(content);
    2802         }
    2803 
    2804         // Check for identity constraints
    2805         if (content != 0)
    2806         {
    2807             content = checkIdentityConstraintContent(content);
    2808             if (content != 0)
    2809                 reportSchemaError(content, XMLUni::fgXMLErrDomain, XMLErrs::InvalidElementContent);
    2810         }
    2811     }
    2812 
    2813     // Handle 'type' attribute
    2814     const XMLCh* typeStr = getElementAttValue(elem, SchemaSymbols::fgATT_TYPE, DatatypeValidator::QName);
    2815     if (typeStr)
    2816     {
    2817         if (anonymousType)
    2818         {
    2819             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::ElementWithTypeAndAnonType, name);
    2820         }
    2821         else if (*typeStr)
    2822         {
    2823             const XMLCh* typeLocalPart = getLocalPart(typeStr);
    2824             const XMLCh* typePrefix = getPrefix(typeStr);
    2825             const XMLCh* typeURI = resolvePrefixToURI(elem, typePrefix);
    2826 
    2827             if (!XMLString::equals(typeURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA)
    2828                 || !XMLString::equals(typeLocalPart, SchemaSymbols::fgATTVAL_ANYTYPE))
    2829             {
    2830                 checkEnumerationRequiredNotation(elem, name, typeStr);
    2831 
    2832                 bool noErrorFound = true;
    2833                 const XMLCh* anotherSchemaURI = checkTypeFromAnotherSchema(elem, typeStr);
    2834 
    2835                 // get complex type info
    2836                 typeInfo = getElementComplexTypeInfo(elem, typeStr, anotherSchemaURI);
    2837 
    2838                 // get simple type validtor - if not a complex type
    2839                 if (typeInfo)
    2840                     validator = typeInfo->getDatatypeValidator();
    2841                 else
    2842                     validator = getElementTypeValidator(elem, typeStr, noErrorFound, anotherSchemaURI);
    2843             }
    2844         }
    2845     }
    2846 
    2847     // check for duplicate elements with different types.
    2848     if (isDuplicate)
    2849     {
    2850         DatatypeValidator* eltDV = elemDecl->getDatatypeValidator();
    2851         ComplexTypeInfo*   eltTypeInfo = elemDecl->getComplexTypeInfo();
    2852 
    2853         if ( (eltTypeInfo != typeInfo) || (eltDV != validator))  {
    2854             reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::DuplicateElementDeclaration, name);
    2855         }
    2856     }
    2857     // Set element declararion type information
    2858     else
    2859     {
    2860         elemDecl->setDatatypeValidator(validator);
    2861         elemDecl->setComplexTypeInfo(typeInfo);
    2862 
    2863         if (validator)
    2864             elemDecl->setModelType(SchemaElementDecl::Simple);
    2865         else if (typeInfo)
    2866             elemDecl->setModelType((SchemaElementDecl::ModelTypes)typeInfo->getContentType());
    2867 
    2868         if (topLevel) {
    2869 
    2870             // Handle the substitutionGroup
    2871             const XMLCh* subsGroupName = getElementAttValue(elem, SchemaSymbols::fgATT_SUBSTITUTIONGROUP, DatatypeValidator::QName);
    2872             if (subsGroupName && *subsGroupName)
    2873                  processSubstitutionGroup(elem, elemDecl, typeInfo, validator, subsGroupName);
    2874         }
    2875 
    2876         // process identity constraints
    2877         DOMElement* ic = XUtil::getFirstChildElementNS(
    2878             elem, fgIdentityConstraints, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, 3);
    2879 
    2880         if (ic)
    2881             processElemDeclIC(ic, elemDecl);
    2882     }
    2883 
    2884     if (!typeInfo && !validator)
    2885     {
    2886         if (!isDuplicate)
    2887         {
    2888             elemDecl->setModelType(SchemaElementDecl::Any);
    2889             elemDecl->setAttWildCard(
    2890                 new (fGrammarPoolMemoryManager) SchemaAttDef(
    2891                     XMLUni::fgZeroLenString, XMLUni::fgZeroLenString,
    2892                     fEmptyNamespaceURI, XMLAttDef::Any_Any,
    2893                     XMLAttDef::ProcessContents_Lax, fGrammarPoolMemoryManager
    2894                 )
    2895             );
    2896         }
    2897     }
    2898     else if (valueConstraint)
    2899     {
    2900         if (!checkElemDeclValueConstraint(elem, elemDecl, valueConstraint, typeInfo, validator)
    2901             && !isDuplicate)
    2902         {
    2903             int miscFlags = elemDecl->getMiscFlags();
    2904             miscFlags &= ~ SchemaSymbols::XSD_FIXED;
    2905             elemDecl->setDefaultValue(0);
    2906             elemDecl->setMiscFlags(miscFlags);
    2907         }
    2908     }
    2909 
    2910     return elemDecl;
     3001                                                                        const bool topLevel)
     3002{
     3003        DEBUG_SCHEMA_MESSAGE
     3004        (
     3005                "TraverseSchema::traverseElementDecl("
     3006                << elem
     3007                << topLevel
     3008                << ')'
     3009        );
     3010
     3011        NamespaceScopeManager nsMgr(elem, fSchemaInfo, this);
     3012
     3013
     3014
     3015        // if local element and ref attribute exists
     3016        if (!topLevel)
     3017        {
     3018                const XMLCh* refName = getElementAttValue(elem, SchemaSymbols::fgATT_REF, DatatypeValidator::QName);
     3019                if (refName)
     3020                {
     3021                        return processElementDeclRef(elem, refName);
     3022                }
     3023        }
     3024
     3025        // check for empty name
     3026        const XMLCh* name = getElementAttValue(elem, SchemaSymbols::fgATT_NAME, DatatypeValidator::NCName);
     3027        if (!name || !*name)
     3028        {
     3029                reportSchemaError(elem, XMLUni::fgXMLErrDomain, XMLErrs::NoNameRefElement);
     3030                return 0;
     3031        }