/*

 * 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: DTDScanner.hpp 568078 2007-08-21 11:43:25Z amassari $

 */

#if !defined(DTDSCANNER_HPP)

#define DTDSCANNER_HPP

#include <xercesc/validators/DTD/DTDGrammar.hpp>

#include <xercesc/validators/DTD/DTDEntityDecl.hpp>

XERCES_CPP_NAMESPACE_BEGIN

class XMLScanner;

/*

 * Default implementation of an XML DTD scanner.

 */

class DocTypeHandler;

class VALIDATORS_EXPORT DTDScanner : public XMemory

{

public:

    // -----------------------------------------------------------------------

    //  Class specific types

    //

    //  EntityExpRes

    //      Returned from scanEntityRef() to indicate how the expanded text

    //      was treated.

    //

    //  IDTypes

    //      Type of the ID

    // -----------------------------------------------------------------------

    enum EntityExpRes

    {

        EntityExp_Failed

        , EntityExp_Pushed

        , EntityExp_Returned

    };

    enum IDTypes

    {

        IDType_Public

        , IDType_External

        , IDType_Either

    };

    // -----------------------------------------------------------------------

    //  Constructors and Destructor

    // -----------------------------------------------------------------------

    DTDScanner

    (

          DTDGrammar*           dtdGrammar

        , DocTypeHandler* const docTypeHandler

        , MemoryManager* const  grammarPoolMemoryManager

        , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager

    );

    virtual ~DTDScanner();

    // -----------------------------------------------------------------------

    //  Getter methods

    // -----------------------------------------------------------------------

    DocTypeHandler* getDocTypeHandler();

    const DocTypeHandler* getDocTypeHandler() const;

    // -----------------------------------------------------------------------

    //  Setter methods

    //

    //  setScannerInfo() is called by the scanner to tell the DTDScanner

    //  about the stuff it needs to have access to.

    // -----------------------------------------------------------------------

    void setScannerInfo

    (

        XMLScanner* const           owningScanner

        , ReaderMgr* const          readerMgr

        , XMLBufferMgr* const       bufMgr

    );

    void setDocTypeHandler

    (

            DocTypeHandler* const handlerToSet

    );

    void scanExtSubsetDecl(const bool inIncludeSect, const bool isDTD);

    bool scanInternalSubset();

    bool scanId

    (

                XMLBuffer&  pubIdToFill

        ,       XMLBuffer&  sysIdToFill

        , const IDTypes     whatKind

    );

private:

    // -----------------------------------------------------------------------

    // Unimplemented constructors and operators

    // -----------------------------------------------------------------------

    DTDScanner(const DTDScanner &);

    DTDScanner& operator = (const  DTDScanner&);

    // -----------------------------------------------------------------------

    //  Private DTD scanning methods. These are all in XMLValidator2.cpp

    // -----------------------------------------------------------------------

    bool checkForPERef

    (

          const bool    inLiteral

        , const bool    inMarkup

    );

    bool expandPERef

    (

        const   bool    scanExternal

        , const bool    inLiteral

        , const bool    inMarkup

        , const bool    throwEndOfExt = false

    );

    bool getQuotedString(XMLBuffer& toFill);

    XMLAttDef* scanAttDef(DTDElementDecl& elemDecl, XMLBuffer& bufToUse);

    bool scanAttValue

    (

        const   XMLCh* const        attrName

        ,       XMLBuffer&          toFill

        , const XMLAttDef::AttTypes type

    );

    void scanAttListDecl();

    ContentSpecNode* scanChildren

    (

        const   DTDElementDecl&     elemDecl

        ,       XMLBuffer&          bufToUse

    );

    bool scanCharRef(XMLCh& toFill, XMLCh& second);

    void scanComment();

    bool scanContentSpec(DTDElementDecl& toFill);

    void scanDefaultDecl(DTDAttDef& toFill);

    void scanElementDecl();

    void scanEntityDecl();

    bool scanEntityDef();

    bool scanEntityLiteral(XMLBuffer& toFill);

    bool scanEntityDef(DTDEntityDecl& decl, const bool isPEDecl);

    EntityExpRes scanEntityRef(XMLCh& firstCh, XMLCh& secondCh, bool& escaped);

    bool scanEnumeration

    (

        const   DTDAttDef&  attDef

        ,       XMLBuffer&  toFill

        , const bool        notation

    );

    bool scanEq();

    void scanIgnoredSection();

    void scanMarkupDecl(const bool parseTextDecl);

    bool scanMixed(DTDElementDecl& toFill);

    void scanNotationDecl();

    void scanPI();

    bool scanPublicLiteral(XMLBuffer& toFill);

    bool scanSystemLiteral(XMLBuffer& toFill);

    void scanTextDecl();

    bool isReadingExternalEntity();

    // -----------------------------------------------------------------------

    //  Private data members

    //

    //  fDocTypeHandler

    //      This holds the optional doc type handler that can be installed

    //      and used to call back for all markup events. It is DTD specific.

    //

    //  fDumAttDef

    //  fDumElemDecl

    //  fDumEntityDecl

    //      These are dummy objects into which mark decls are parsed when

    //      they are just overrides of previously declared markup decls. In

    //      such situations, the first one wins but we need to have somewhere

    //      to parse them into. So these are lazily created and used as needed

    //      when such markup decls are seen.

    //

    //  fInternalSubset

    //      This is used to track whether we are in the internal subset or not,

    //      in which case we are in the external subset.

    //

    //  fNextAttrId

    //      Since att defs are per-element, we don't have a validator wide

    //      attribute def pool. So we use a simpler data structure in each

    //      element decl to store its att defs, and we use this simple counter

    //      to apply a unique id to each new attribute.

    //

    //  fDTDGrammar

    //      The DTD information we scanned like element decl, attribute decl

    //      are stored in this Grammar.

    //

    //  fBufMgr

    //      This is the buffer manager of the scanner. This is provided as a

    //      convenience so that the DTDScanner doesn't have to create its own

    //      buffer manager during the parse process.

    //

    //  fReaderMgr

    //      This is a pointer to the reader manager that is being used by the scanner.

    //

    //  fScanner

    //      The pointer to the scanner to which this DTDScanner belongs

    //

    //  fPEntityDeclPool

    //      This is a pool of EntityDecl objects, which contains all of the

    //      parameter entities that are declared in the DTD subsets.

    //

    //  fEmptyNamespaceId

    //      The uri for all DTD decls

    //

    //  fDocTypeReaderId

    //      The original reader in the fReaderMgr - to be compared against the

    //      current reader to decide whether we are processing an external/internal

    //      declaration

    // -----------------------------------------------------------------------

    MemoryManager*                  fMemoryManager;

    MemoryManager*                  fGrammarPoolMemoryManager;

    DocTypeHandler*                 fDocTypeHandler;

    DTDAttDef*                      fDumAttDef;

    DTDElementDecl*                 fDumElemDecl;

    DTDEntityDecl*                  fDumEntityDecl;

    bool                            fInternalSubset;

    unsigned int                    fNextAttrId;

    DTDGrammar*                     fDTDGrammar;

    XMLBufferMgr*                   fBufMgr;

    ReaderMgr*                      fReaderMgr;

    XMLScanner*                     fScanner;

    NameIdPool<DTDEntityDecl>*      fPEntityDeclPool;

    unsigned int                    fEmptyNamespaceId;

    unsigned int                    fDocTypeReaderId;

};

// ---------------------------------------------------------------------------

//  DTDScanner: Getter methods

// ---------------------------------------------------------------------------

inline DocTypeHandler* DTDScanner::getDocTypeHandler()

{

    return fDocTypeHandler;

}

inline const DocTypeHandler* DTDScanner::getDocTypeHandler() const

{

    return fDocTypeHandler;

}

// ---------------------------------------------------------------------------

//  DTDScanner: Setter methods

// ---------------------------------------------------------------------------

inline void DTDScanner::setDocTypeHandler(DocTypeHandler* const handlerToSet)

{

    fDocTypeHandler = handlerToSet;

}

// -----------------------------------------------------------------------

//  Helper methods

// -----------------------------------------------------------------------

inline bool DTDScanner::isReadingExternalEntity() {

    return (fDocTypeReaderId != fReaderMgr->getCurrentReaderNum());

}

XERCES_CPP_NAMESPACE_END

#endif