| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * $Id: SGXMLScanner.hpp 568078 2007-08-21 11:43:25Z amassari $ |
| */ |
| |
| |
| #if !defined(SGXMLSCANNER_HPP) |
| #define SGXMLSCANNER_HPP |
| |
| #include <xercesc/internal/XMLScanner.hpp> |
| #include <xercesc/util/KVStringPair.hpp> |
| #include <xercesc/util/ValueHashTableOf.hpp> |
| #include <xercesc/util/RefHash3KeysIdPool.hpp> |
| #include <xercesc/validators/common/Grammar.hpp> |
| #include <xercesc/validators/schema/SchemaElementDecl.hpp> |
| |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| class SchemaGrammar; |
| class SchemaValidator; |
| class IdentityConstraintHandler; |
| class IdentityConstraint; |
| class ContentLeafNameTypeVector; |
| class SchemaAttDef; |
| class XMLContentModel; |
| class XSModel; |
| class PSVIAttributeList; |
| class PSVIElement; |
| |
| // This is a scanner class, which process XML Schema grammar. |
| class XMLPARSER_EXPORT SGXMLScanner : public XMLScanner |
| { |
| public : |
| // ----------------------------------------------------------------------- |
| // Constructors and Destructor |
| // ----------------------------------------------------------------------- |
| SGXMLScanner |
| ( |
| XMLValidator* const valToAdopt |
| , GrammarResolver* const grammarResolver |
| , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager |
| ); |
| SGXMLScanner |
| ( |
| XMLDocumentHandler* const docHandler |
| , DocTypeHandler* const docTypeHandler |
| , XMLEntityHandler* const entityHandler |
| , XMLErrorReporter* const errReporter |
| , XMLValidator* const valToAdopt |
| , GrammarResolver* const grammarResolver |
| , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager |
| ); |
| virtual ~SGXMLScanner(); |
| |
| // ----------------------------------------------------------------------- |
| // XMLScanner public virtual methods |
| // ----------------------------------------------------------------------- |
| virtual const XMLCh* getName() const; |
| virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool(); |
| virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const; |
| virtual unsigned int resolveQName |
| ( |
| const XMLCh* const qName |
| , XMLBuffer& prefixBufToFill |
| , const short mode |
| , int& prefixColonPos |
| ); |
| virtual void scanDocument |
| ( |
| const InputSource& src |
| ); |
| virtual bool scanNext(XMLPScanToken& toFill); |
| virtual Grammar* loadGrammar |
| ( |
| const InputSource& src |
| , const short grammarType |
| , const bool toCache = false |
| ); |
| virtual Grammar::GrammarType getCurrentGrammarType() const; |
| |
| protected: |
| // ----------------------------------------------------------------------- |
| // XMLScanner virtual methods |
| // ----------------------------------------------------------------------- |
| virtual void scanReset(const InputSource& src); |
| |
| // ----------------------------------------------------------------------- |
| // SGXMLScanner virtual methods |
| // ----------------------------------------------------------------------- |
| virtual bool scanStartTag(bool& gotData); |
| virtual void scanEndTag(bool& gotData); |
| |
| // ----------------------------------------------------------------------- |
| // Helper methods |
| // ----------------------------------------------------------------------- |
| unsigned int buildAttList |
| ( |
| const RefVectorOf<KVStringPair>& providedAttrs |
| , const unsigned int attCount |
| , XMLElementDecl* elemDecl |
| , RefVectorOf<XMLAttr>& toFill |
| ); |
| bool laxElementValidation(QName* element, ContentLeafNameTypeVector* cv, |
| const XMLContentModel* const cm, |
| const unsigned int parentElemDepth); |
| unsigned int rawAttrScan |
| ( |
| const XMLCh* const elemName |
| , RefVectorOf<KVStringPair>& toFill |
| , bool& isEmpty |
| ); |
| void updateNSMap |
| ( |
| const XMLCh* const attrName |
| , const XMLCh* const attrValue |
| ); |
| unsigned int resolvePrefix |
| ( |
| const XMLCh* const prefix |
| , const ElemStack::MapModes mode |
| ); |
| void resizeElemState(); |
| |
| void updateNSMap |
| ( |
| const XMLCh* const attrName |
| , const XMLCh* const attrValue |
| , const int colonPosition |
| ); |
| void resizeRawAttrColonList(); |
| unsigned int resolveQNameWithColon |
| ( |
| const XMLCh* const qName |
| , XMLBuffer& prefixBufToFill |
| , const short mode |
| , const int prefixColonPos |
| ); |
| // ----------------------------------------------------------------------- |
| // Data members |
| // |
| // fRawAttrList |
| // During the initial scan of the attributes we can only do a raw |
| // scan for key/value pairs. So this vector is used to store them |
| // until they can be processed (and put into fAttrList.) |
| // |
| // fSchemaValidator |
| // The Schema validator instance. |
| // |
| // fSeeXsi |
| // This flag indicates a schema has been seen. |
| // |
| // fElemState |
| // fElemStateSize |
| // Stores an element next state from DFA content model - used for |
| // wildcard validation |
| // |
| // fElemNonDeclPool |
| // registry for elements without decls in the grammar |
| // fElemCount |
| // count of the number of start tags seen so far (starts at 1). |
| // Used for duplicate attribute detection/processing of required/defaulted attributes |
| // fAttDefRegistry |
| // mapping from XMLAttDef instances to the count of the last |
| // start tag where they were utilized. |
| // fUndeclaredAttrRegistryNS |
| // mapping of namespaceId/localName pairs to the count of the last |
| // start tag in which they occurred. |
| // fPSVIAttrList |
| // PSVI attribute list implementation that needs to be |
| // filled when a PSVIHandler is registered |
| // |
| // ----------------------------------------------------------------------- |
| bool fSeeXsi; |
| Grammar::GrammarType fGrammarType; |
| unsigned int fElemStateSize; |
| unsigned int* fElemState; |
| XMLBuffer fContent; |
| ValueHashTableOf<XMLCh>* fEntityTable; |
| RefVectorOf<KVStringPair>* fRawAttrList; |
| unsigned int fRawAttrColonListSize; |
| int* fRawAttrColonList; |
| SchemaGrammar* fSchemaGrammar; |
| SchemaValidator* fSchemaValidator; |
| IdentityConstraintHandler* fICHandler; |
| RefHash3KeysIdPool<SchemaElementDecl>* fElemNonDeclPool; |
| unsigned int fElemCount; |
| RefHashTableOf<unsigned int>* fAttDefRegistry; |
| RefHash2KeysTableOf<unsigned int>* fUndeclaredAttrRegistryNS; |
| PSVIAttributeList * fPSVIAttrList; |
| XSModel* fModel; |
| PSVIElement* fPSVIElement; |
| ValueStackOf<bool>* fErrorStack; |
| PSVIElemContext fPSVIElemContext; |
| |
| private : |
| // ----------------------------------------------------------------------- |
| // Unimplemented constructors and operators |
| // ----------------------------------------------------------------------- |
| SGXMLScanner(); |
| SGXMLScanner(const SGXMLScanner&); |
| SGXMLScanner& operator=(const SGXMLScanner&); |
| |
| // ----------------------------------------------------------------------- |
| // XMLScanner virtual methods |
| // ----------------------------------------------------------------------- |
| virtual void scanCDSection(); |
| virtual void scanCharData(XMLBuffer& toToUse); |
| virtual EntityExpRes scanEntityRef |
| ( |
| const bool inAttVal |
| , XMLCh& firstCh |
| , XMLCh& secondCh |
| , bool& escaped |
| ); |
| virtual void scanDocTypeDecl(); |
| virtual void sendCharData(XMLBuffer& toSend); |
| virtual InputSource* resolveSystemId(const XMLCh* const sysId |
| ,const XMLCh* const pubId); |
| |
| // ----------------------------------------------------------------------- |
| // Private helper methods |
| // ----------------------------------------------------------------------- |
| void commonInit(); |
| void cleanUp(); |
| |
| bool normalizeAttValue |
| ( |
| const XMLAttDef* const attDef |
| , const XMLCh* const attrName |
| , const XMLCh* const value |
| , XMLBuffer& toFill |
| ); |
| bool normalizeAttRawValue |
| ( |
| const XMLCh* const attrName |
| , const XMLCh* const value |
| , XMLBuffer& toFill |
| ); |
| unsigned int resolvePrefix |
| ( |
| const XMLCh* const prefix |
| , XMLBuffer& uriBufToFill |
| , const ElemStack::MapModes mode |
| ); |
| void scanRawAttrListforNameSpaces(int attCount); |
| void parseSchemaLocation(const XMLCh* const schemaLocationStr); |
| void resolveSchemaGrammar(const XMLCh* const loc, const XMLCh* const uri); |
| bool switchGrammar(const XMLCh* const newGrammarNameSpace); |
| bool anyAttributeValidation(SchemaAttDef* attWildCard, |
| unsigned int uriId, |
| bool& skipThisOne, |
| bool& laxThisOne); |
| |
| // ----------------------------------------------------------------------- |
| // Private scanning methods |
| // ----------------------------------------------------------------------- |
| bool basicAttrValueScan |
| ( |
| const XMLCh* const attrName |
| , XMLBuffer& toFill |
| ); |
| bool scanAttValue |
| ( |
| const XMLAttDef* const attDef |
| , XMLBuffer& toFill |
| ); |
| bool scanContent(); |
| |
| // ----------------------------------------------------------------------- |
| // IdentityConstraints Activation methods |
| // ----------------------------------------------------------------------- |
| inline bool toCheckIdentityConstraint() const; |
| |
| // ----------------------------------------------------------------------- |
| // Grammar preparsing methods |
| // ----------------------------------------------------------------------- |
| Grammar* loadXMLSchemaGrammar(const InputSource& src, const bool toCache = false); |
| |
| // ----------------------------------------------------------------------- |
| // PSVI handling methods |
| // ----------------------------------------------------------------------- |
| void endElementPSVI(SchemaElementDecl* const elemDecl, |
| DatatypeValidator* const memberDV); |
| void resetPSVIElemContext(); |
| }; |
| |
| inline const XMLCh* SGXMLScanner::getName() const |
| { |
| return XMLUni::fgSGXMLScanner; |
| } |
| |
| inline bool SGXMLScanner::toCheckIdentityConstraint() const |
| { |
| return fValidate && fIdentityConstraintChecking && fICHandler; |
| } |
| |
| inline Grammar::GrammarType SGXMLScanner::getCurrentGrammarType() const |
| { |
| return fGrammarType; |
| } |
| |
| XERCES_CPP_NAMESPACE_END |
| |
| #endif |
