/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   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 .

 */

#include <sax/fastparser.hxx>

#include <sax/fastattribs.hxx>

#include <utility>

#include <xml2utf.hxx>

#include <com/sun/star/io/XSeekable.hpp>

#include <com/sun/star/lang/DisposedException.hpp>

#include <com/sun/star/lang/IllegalArgumentException.hpp>

#include <com/sun/star/uno/XComponentContext.hpp>

#include <com/sun/star/container/XMap.hpp>

#include <com/sun/star/xml/sax/FastToken.hpp>

#include <com/sun/star/xml/sax/SAXParseException.hpp>

#include <com/sun/star/xml/sax/XFastContextHandler.hpp>

#include <cppuhelper/implbase.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <cppuhelper/exc_hlp.hxx>

#include <osl/conditn.hxx>

#include <rtl/ref.hxx>

#include <sal/log.hxx>

#include <salhelper/thread.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <comphelper/string.hxx>

#include <o3tl/string_view.hxx>

#include <queue>

#include <memory>

#include <mutex>

#include <optional>

#include <stack>

#include <string_view>

#include <unordered_map>

#include <vector>

#include <cassert>

#include <cstring>

#include <libxml/parser.h>

// Inverse of libxml's BAD_CAST.

#define XML_CAST( str ) reinterpret_cast< const char* >( str )

using namespace ::osl;

using namespace ::cppu;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star::lang;

using namespace ::com::sun::star::xml::sax;

using namespace ::com::sun::star::io;

using namespace com::sun::star;

using namespace sax_fastparser;

static void NormalizeURI( OUString& rName );

namespace {

struct Event;

class FastLocatorImpl;

struct NamespaceDefine;

struct Entity;

typedef std::unordered_map< OUString, sal_Int32 > NamespaceMap;

struct EventList

{

    std::vector<Event> maEvents;

    bool mbIsAttributesEmpty;

};

enum class CallbackType { START_ELEMENT, END_ELEMENT, CHARACTERS, PROCESSING_INSTRUCTION, DONE, EXCEPTION };

struct Event

{

    CallbackType maType;

    sal_Int32 mnElementToken;

    OUString msNamespace;

    OUString msElementName;

    rtl::Reference< FastAttributeList > mxAttributes;

    rtl::Reference< FastAttributeList > mxDeclAttributes;

    OUString msChars;

};

struct NameWithToken

{

    OUString msName;

    sal_Int32 mnToken;

    NameWithToken(OUString sName, sal_Int32 nToken) :

        msName(std::move(sName)), mnToken(nToken) {}

};

struct SaxContext

{

    Reference< XFastContextHandler > mxContext;

    sal_Int32 mnElementToken;

    std::optional<OUString>  moNamespace;

    std::optional<OUString> moElementName;

    SaxContext( sal_Int32 nElementToken, const OUString& aNamespace, const OUString& aElementName ):

            mnElementToken(nElementToken)

    {

        if (nElementToken == FastToken::DONTKNOW)

        {

            moNamespace = aNamespace;

            moElementName = aElementName;

        }

    }

};

struct ParserData

{

    css::uno::Reference< css::xml::sax::XFastDocumentHandler > mxDocumentHandler;

    rtl::Reference<FastTokenHandlerBase>                       mxTokenHandler;

    css::uno::Reference< css::xml::sax::XErrorHandler >        mxErrorHandler;

    css::uno::Reference< css::xml::sax::XFastNamespaceHandler >mxNamespaceHandler;

    ParserData();

};

struct NamespaceDefine

{

    OString     maPrefix;

    sal_Int32   mnToken;

    OUString    maNamespaceURL;

    NamespaceDefine( OString aPrefix, sal_Int32 nToken, OUString aNamespaceURL )

        : maPrefix(std::move( aPrefix )), mnToken( nToken ), maNamespaceURL(std::move( aNamespaceURL )) {}

    NamespaceDefine() : mnToken(-1) {}

};

// Entity binds all information needed for a single file | single call of parseStream

struct Entity : public ParserData

{

    // Amount of work producer sends to consumer in one iteration:

    static const size_t mnEventListSize = 1000;

    // unique for each Entity instance:

    // Number of valid events in mxProducedEvents:

    size_t mnProducedEventsSize;

    std::optional<EventList> mxProducedEvents;

    std::queue<EventList> maPendingEvents;

    std::queue<EventList> maUsedEvents;

    std::mutex maEventProtector;

    static const size_t mnEventLowWater = 4;

    static const size_t mnEventHighWater = 8;

    osl::Condition maConsumeResume;

    osl::Condition maProduceResume;

    // Event we use to store data if threading is disabled:

    Event maSharedEvent;

    // copied in copy constructor:

    // Allow to disable threading for small documents:

    bool                                    mbEnableThreads;

    css::xml::sax::InputSource              maStructSource;

    xmlParserCtxtPtr                        mpParser;

    ::sax_expatwrap::XMLFile2UTFConverter   maConverter;

    // Exceptions cannot be thrown through the C-XmlParser (possible

    // resource leaks), therefore any exception thrown by a UNO callback

    // must be saved somewhere until the C-XmlParser is stopped.

    css::uno::Any                           maSavedException;

    std::mutex                              maSavedExceptionMutex;

    void saveException( const Any & e );

    // Thread-safe check if maSavedException has value

    bool hasException();

    void throwException( const ::rtl::Reference< FastLocatorImpl > &xDocumentLocator,

                         bool mbDuringParse );

    std::stack< NameWithToken, std::vector<NameWithToken> > maNamespaceStack;

    /* Context for main thread consuming events.

     * startElement() stores the data, which characters() and endElement() uses

     */

    std::stack< SaxContext, std::vector<SaxContext> >  maContextStack;

    // Determines which elements of maNamespaceDefines are valid in current context

    std::stack< sal_uInt32, std::vector<sal_uInt32> >  maNamespaceCount;

    std::vector< NamespaceDefine >                     maNamespaceDefines;

    explicit Entity( const ParserData& rData );

    Entity( const Entity& rEntity ) = delete;

    Entity& operator=( const Entity& rEntity ) = delete;

    void startElement( Event const *pEvent );

    void characters( const OUString& sChars );

    void endElement();

    void processingInstruction( const OUString& rTarget, const OUString& rData );

    void transferUsedEvents();

    EventList& getEventList();

    Event& getEvent( CallbackType aType );

};

// Stuff for custom entity names

struct ReplacementPair

{

    OUString name;

    OUString replacement;

};

inline bool operator<(const ReplacementPair& lhs, const ReplacementPair& rhs)

{

    return lhs.name < rhs.name;

}

inline bool operator<(const ReplacementPair& lhs, const char* rhs)

{

    return lhs.name.compareToAscii(rhs) < 0;

}

} // namespace

namespace sax_fastparser {

class FastSaxParserImpl

{

public:

    explicit FastSaxParserImpl();

    ~FastSaxParserImpl();

private:

    std::vector<ReplacementPair> m_Replacements;

    std::vector<xmlEntityPtr> m_TemporalEntities;

public:

    // XFastParser

    /// @throws css::xml::sax::SAXException

    /// @throws css::io::IOException

    /// @throws css::uno::RuntimeException

    void parseStream( const css::xml::sax::InputSource& aInputSource );

    /// @throws css::uno::RuntimeException

    void setFastDocumentHandler( const css::uno::Reference< css::xml::sax::XFastDocumentHandler >& Handler );

    /// @throws css::uno::RuntimeException

    void setTokenHandler( const css::uno::Reference< css::xml::sax::XFastTokenHandler >& Handler );

    /// @throws css::lang::IllegalArgumentException

    /// @throws css::uno::RuntimeException

    void registerNamespace( const OUString& NamespaceURL, sal_Int32 NamespaceToken );

    /// @throws css::lang::IllegalArgumentException

    /// @throws css::uno::RuntimeException

    OUString const & getNamespaceURL( std::u16string_view rPrefix );

    /// @throws css::uno::RuntimeException

    void setErrorHandler( const css::uno::Reference< css::xml::sax::XErrorHandler >& Handler );

    /// @throws css::uno::RuntimeException

    void setNamespaceHandler( const css::uno::Reference< css::xml::sax::XFastNamespaceHandler >& Handler);

    // Fake DTD file

    void setCustomEntityNames(

       const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>& replacements);

    // called by the C callbacks of the expat parser

    void callbackStartElement( const xmlChar *localName , const xmlChar* prefix, const xmlChar* URI,

        int numNamespaces, const xmlChar** namespaces, int numAttributes, const xmlChar **attributes );

    void callbackEndElement();

    void callbackCharacters( const xmlChar* s, int nLen );

    void callbackProcessingInstruction( const xmlChar *target, const xmlChar *data );

    xmlEntityPtr callbackGetEntity( const xmlChar *name );

    void pushEntity(const ParserData&, xml::sax::InputSource const&);

    void popEntity();

    Entity& getEntity()             { return *mpTop; }

    void parse();

    void produce( bool bForceFlush = false );

    bool m_bIgnoreMissingNSDecl;

    bool m_bDisableThreadedParser;

    css::uno::Reference<css::container::XMap> mxMap; /// _ prefix string mapper for translation

private:

    bool consume(EventList&);

    void deleteUsedEvents();

    void sendPendingCharacters();

    void addUnknownElementWithPrefix(const xmlChar **attributes, int i, rtl::Reference< FastAttributeList > const & xAttributes);

    sal_Int32 GetToken( const xmlChar* pName );

    /// @throws css::xml::sax::SAXException

    sal_Int32 GetTokenWithPrefix( std::string_view sPrefix, const xmlChar* pName );

    /// @throws css::xml::sax::SAXException

    OUString const & GetNamespaceURL( std::string_view rPrefix );

    sal_Int32 GetNamespaceToken( const OUString& rNamespaceURL );

    sal_Int32 GetTokenWithContextNamespace( sal_Int32 nNamespaceToken, const xmlChar* pName );

    void DefineNamespace( const OString& rPrefix, const OUString& namespaceURL );

private:

    std::mutex maMutex; ///< Protecting whole parseStream() execution

    ::rtl::Reference< FastLocatorImpl >     mxDocumentLocator;

    NamespaceMap                            maNamespaceMap;

    ParserData maData;                      /// Cached parser configuration for next call of parseStream().

    Entity *mpTop;                          /// std::stack::top() is amazingly slow => cache this.

    std::stack< Entity > maEntities;        /// Entity stack for each call of parseStream().

    std::vector<char> pendingCharacters;    /// Data from characters() callback that needs to be sent.

};

} // namespace sax_fastparser

namespace {

class ParserThread: public salhelper::Thread

{

    FastSaxParserImpl *mpParser;

public:

    explicit ParserThread(FastSaxParserImpl *pParser): Thread("Parser"), mpParser(pParser) {}

private:

    virtual void execute() override

    {

        try

        {

            mpParser->parse();

        }

        catch (...)

        {

            Entity &rEntity = mpParser->getEntity();

            rEntity.getEvent( CallbackType::EXCEPTION );

            mpParser->produce( true );

        }

    }

};

extern "C" {

static void call_callbackStartElement(void *userData, const xmlChar *localName , const xmlChar* prefix, const xmlChar* URI,

    int numNamespaces, const xmlChar** namespaces, int numAttributes, int /*defaultedAttributes*/, const xmlChar **attributes)

{

    FastSaxParserImpl* pFastParser = static_cast<FastSaxParserImpl*>( userData );

    pFastParser->callbackStartElement( localName, prefix, URI, numNamespaces, namespaces, numAttributes, attributes );

}

static void call_callbackEndElement(void *userData, const xmlChar* /*localName*/, const xmlChar* /*prefix*/, const xmlChar* /*URI*/)

{

    FastSaxParserImpl* pFastParser = static_cast<FastSaxParserImpl*>( userData );

    pFastParser->callbackEndElement();

}

static void call_callbackCharacters( void *userData , const xmlChar *s , int nLen )

{

    FastSaxParserImpl* pFastParser = static_cast<FastSaxParserImpl*>( userData );

    pFastParser->callbackCharacters( s, nLen );

}

static void call_callbackProcessingInstruction( void *userData, const xmlChar *target, const xmlChar *data )

{

    FastSaxParserImpl* pFastParser = static_cast<FastSaxParserImpl*>( userData );

    pFastParser->callbackProcessingInstruction( target, data );

}

static xmlEntityPtr call_callbackGetEntity( void *userData, const xmlChar *name)

{

    FastSaxParserImpl* pFastParser = static_cast<FastSaxParserImpl*>( userData );

    return pFastParser->callbackGetEntity( name );

}

}

class FastLocatorImpl : public WeakImplHelper< XLocator >

{

public:

    explicit FastLocatorImpl(FastSaxParserImpl *p) : mpParser(p) {}

    void dispose() { mpParser = nullptr; }

    /// @throws RuntimeException

    void checkDispose() const { if( !mpParser ) throw DisposedException(); }

    //XLocator

    virtual sal_Int32 SAL_CALL getColumnNumber() override;

    virtual sal_Int32 SAL_CALL getLineNumber() override;

    virtual OUString SAL_CALL getPublicId() override;

    virtual OUString SAL_CALL getSystemId() override;

private:

    FastSaxParserImpl *mpParser;

};

sal_Int32 SAL_CALL FastLocatorImpl::getColumnNumber()

{

    checkDispose();

    return xmlSAX2GetColumnNumber( mpParser->getEntity().mpParser );

}

sal_Int32 SAL_CALL FastLocatorImpl::getLineNumber()

{

    checkDispose();

    return xmlSAX2GetLineNumber( mpParser->getEntity().mpParser );

}

OUString SAL_CALL FastLocatorImpl::getPublicId()

{

    checkDispose();

    return mpParser->getEntity().maStructSource.sPublicId;

}

OUString SAL_CALL FastLocatorImpl::getSystemId()

{

    checkDispose();

    return mpParser->getEntity().maStructSource.sSystemId;

}

ParserData::ParserData()

{}

Entity::Entity(const ParserData& rData)

    : ParserData(rData)

    , mnProducedEventsSize(0)

    , mbEnableThreads(false)

    , mpParser(nullptr)

{

}

void Entity::startElement( Event const *pEvent )

{

    const sal_Int32& nElementToken = pEvent->mnElementToken;

    const OUString& aNamespace = pEvent->msNamespace;

    const OUString& aElementName = pEvent->msElementName;

    // Use un-wrapped pointers to avoid significant acquire/release overhead

    XFastContextHandler *pParentContext = nullptr;

    if( !maContextStack.empty() )

    {

        pParentContext = maContextStack.top().mxContext.get();

        if( !pParentContext )

        {

            maContextStack.push( SaxContext(nElementToken, aNamespace, aElementName) );

            return;

        }

    }

    maContextStack.push( SaxContext( nElementToken, aNamespace, aElementName ) );

    try

    {

        const Reference< XFastAttributeList > xAttr( pEvent->mxAttributes );

        Reference< XFastContextHandler > xContext;

        if ( mxNamespaceHandler.is() )

        {

            const Sequence< xml::Attribute > NSDeclAttribs = pEvent->mxDeclAttributes->getUnknownAttributes();

            for (const auto& rNSDeclAttrib : NSDeclAttribs)

            {

                mxNamespaceHandler->registerNamespace( rNSDeclAttrib.Name, rNSDeclAttrib.Value );

            }

        }

        if( nElementToken == FastToken::DONTKNOW )

        {

            if( pParentContext )

                xContext = pParentContext->createUnknownChildContext( aNamespace, aElementName, xAttr );

            else if( mxDocumentHandler.is() )

                xContext = mxDocumentHandler->createUnknownChildContext( aNamespace, aElementName, xAttr );

            if( xContext.is() )

            {

                xContext->startUnknownElement( aNamespace, aElementName, xAttr );

            }

        }

        else

        {

            if( pParentContext )

                xContext = pParentContext->createFastChildContext( nElementToken, xAttr );

            else if( mxDocumentHandler.is() )

                xContext = mxDocumentHandler->createFastChildContext( nElementToken, xAttr );

            if( xContext.is() )

                xContext->startFastElement( nElementToken, xAttr );

        }

        // swap the reference we own in to avoid referencing thrash.

        maContextStack.top().mxContext = std::move( xContext );

    }

    catch (...)

    {

        saveException( ::cppu::getCaughtException() );

    }

}

void Entity::characters( const OUString& sChars )

{

    if (maContextStack.empty())

    {

        // Malformed XML stream !?

        return;

    }

    XFastContextHandler * pContext( maContextStack.top().mxContext.get() );

    if( pContext ) try

    {

        pContext->characters( sChars );

    }

    catch (...)

    {

        saveException( ::cppu::getCaughtException() );

    }

}

void Entity::endElement()

{

    if (maContextStack.empty())

    {

        // Malformed XML stream !?

        return;

    }

    const SaxContext& aContext = maContextStack.top();

    XFastContextHandler* pContext( aContext.mxContext.get() );

    if( pContext )

        try

        {

            sal_Int32 nElementToken = aContext.mnElementToken;

            if( nElementToken != FastToken::DONTKNOW )

                pContext->endFastElement( nElementToken );

            else

                pContext->endUnknownElement( *aContext.moNamespace, *aContext.moElementName );

        }

        catch (...)

        {

            saveException( ::cppu::getCaughtException() );

        }

    maContextStack.pop();

}

void Entity::processingInstruction( const OUString& rTarget, const OUString& rData )

{

    if( mxDocumentHandler.is() ) try

    {

        mxDocumentHandler->processingInstruction( rTarget, rData );

    }

    catch (...)

    {

        saveException( ::cppu::getCaughtException() );

    }

}

void Entity::transferUsedEvents()

{

    std::unique_lock aGuard(maEventProtector);

    if (!maUsedEvents.empty())

    {

        mxProducedEvents = std::move(maUsedEvents.front());

        maUsedEvents.pop();

        aGuard.unlock(); // unlock

        mnProducedEventsSize = 0;

    }

}

EventList& Entity::getEventList()

{

    if (!mxProducedEvents)

    {

        transferUsedEvents();

        if (!mxProducedEvents)

        {

            mxProducedEvents.emplace();

            mxProducedEvents->maEvents.resize(mnEventListSize);

            mxProducedEvents->mbIsAttributesEmpty = false;

            mnProducedEventsSize = 0;

        }

    }

    return *mxProducedEvents;

}

Event& Entity::getEvent( CallbackType aType )

{

    if (!mbEnableThreads)

        return maSharedEvent;

    EventList& rEventList = getEventList();

    if (mnProducedEventsSize == rEventList.maEvents.size())

    {

        SAL_WARN_IF(!maSavedException.hasValue(), "sax",

            "Event vector should only exceed " << mnEventListSize <<

            " temporarily while an exception is pending");

        rEventList.maEvents.resize(mnProducedEventsSize + 1);

    }

    Event& rEvent = rEventList.maEvents[mnProducedEventsSize++];

    rEvent.maType = aType;

    return rEvent;

}

OUString lclGetErrorMessage( xmlParserCtxtPtr ctxt, std::u16string_view sSystemId, sal_Int32 nLine )

{

    const char* pMessage;

    const xmlError* error = xmlCtxtGetLastError( ctxt );

    if( error && error->message )

        pMessage = error->message;

    else

        pMessage = "unknown error";

    return OUString::Concat("[") + sSystemId + " line " + OUString::number(nLine) + "]: " +

           OUString(pMessage, strlen(pMessage), RTL_TEXTENCODING_ASCII_US);

}

// throw an exception, but avoid callback if

// during a threaded produce

void Entity::throwException( const ::rtl::Reference< FastLocatorImpl > &xDocumentLocator,

                             bool mbDuringParse )

{

    // Error during parsing !

    Any savedException;

    {

        std::scoped_lock g(maSavedExceptionMutex);

        if (maSavedException.hasValue())

        {

            savedException.setValue(&maSavedException, cppu::UnoType<decltype(maSavedException)>::get());

        }

    }

    SAXParseException aExcept(

        lclGetErrorMessage( mpParser,

                            xDocumentLocator->getSystemId(),

                            xDocumentLocator->getLineNumber() ),

        Reference< XInterface >(),

        savedException,

        xDocumentLocator->getPublicId(),

        xDocumentLocator->getSystemId(),

        xDocumentLocator->getLineNumber(),

        xDocumentLocator->getColumnNumber()

    );

    // error handler is set, it may throw the exception

    if( !mbDuringParse || !mbEnableThreads )

    {

        if (mxErrorHandler.is() )

            mxErrorHandler->fatalError( Any( aExcept ) );

    }

    // error handler has not thrown, but parsing must stop => throw ourselves

    throw aExcept;

}

// In the single threaded case we emit events via our C

// callbacks, so any exception caught must be queued up until

// we can safely re-throw it from our C++ parent of parse()

// If multi-threaded, we need to push an EXCEPTION event, at

// which point we transfer ownership of maSavedException to

// the consuming thread.

void Entity::saveException( const Any & e )

{

    // fdo#81214 - allow the parser to run on after an exception,

    // unexpectedly some 'startElements' produce a UNO_QUERY_THROW

    // for XComponent; and yet expect to continue parsing.

    SAL_WARN("sax", "Unexpected exception from XML parser " << exceptionToString(e));

    std::scoped_lock g(maSavedExceptionMutex);

    if (maSavedException.hasValue())

    {

        SAL_INFO("sax.fastparser", "discarding exception, already have one");

    }

    else

    {

        maSavedException = e;

    }

}

bool Entity::hasException()

{

    std::scoped_lock g(maSavedExceptionMutex);

    return maSavedException.hasValue();

}

} // namespace

namespace sax_fastparser {

FastSaxParserImpl::FastSaxParserImpl() :

    m_bIgnoreMissingNSDecl(false),

    m_bDisableThreadedParser(false),

    mpTop(nullptr)

{

    mxDocumentLocator.set( new FastLocatorImpl( this ) );

}

FastSaxParserImpl::~FastSaxParserImpl()

{

    if( mxDocumentLocator.is() )

        mxDocumentLocator->dispose();

    for (auto& entity : m_TemporalEntities)

    {

        if (!entity)

            continue;

        xmlNodePtr pPtr = reinterpret_cast<xmlNodePtr>(entity);

        xmlUnlinkNode(pPtr);

        xmlFreeNode(pPtr);

    }

}

void FastSaxParserImpl::DefineNamespace( const OString& rPrefix, const OUString& namespaceURL )

{

    Entity& rEntity = getEntity();

    assert(!rEntity.maNamespaceCount.empty()); // need a context!

    sal_uInt32 nOffset = rEntity.maNamespaceCount.top()++;

    if( rEntity.maNamespaceDefines.size() <= nOffset )

        rEntity.maNamespaceDefines.resize( rEntity.maNamespaceDefines.size() + 64 );

    rEntity.maNamespaceDefines[nOffset] = NamespaceDefine( rPrefix, GetNamespaceToken( namespaceURL ), namespaceURL );

}

sal_Int32 FastSaxParserImpl::GetToken(const xmlChar* pName)

{

    return FastTokenHandlerBase::getTokenFromChars( getEntity(). mxTokenHandler.get(),

                                                    XML_CAST( pName ) ); // uses utf-8

}

sal_Int32 FastSaxParserImpl::GetTokenWithPrefix( std::string_view sPrefix, const xmlChar* pName )

{

    Entity& rEntity = getEntity();

    if (rEntity.maNamespaceCount.empty())

        return FastToken::DONTKNOW;

    sal_uInt32 nNamespace = rEntity.maNamespaceCount.top();

    while( nNamespace-- )

    {

        const auto & rNamespaceDefine = rEntity.maNamespaceDefines[nNamespace];

        if( rNamespaceDefine.maPrefix == sPrefix )

            return GetTokenWithContextNamespace(rNamespaceDefine.mnToken, pName);

    }

    if (!m_bIgnoreMissingNSDecl)

        throw SAXException("No namespace defined for " + OStringToOUString(sPrefix,

            RTL_TEXTENCODING_UTF8), {}, {});

    return FastToken::DONTKNOW;

}

sal_Int32 FastSaxParserImpl::GetNamespaceToken( const OUString& rNamespaceURL )

{

    NamespaceMap::iterator aIter( maNamespaceMap.find( rNamespaceURL ) );

    if( aIter != maNamespaceMap.end() )

        return (*aIter).second;

    else

        return FastToken::DONTKNOW;

}

OUString const & FastSaxParserImpl::GetNamespaceURL( std::string_view rPrefix )

{

    Entity& rEntity = getEntity();

    if( !rEntity.maNamespaceCount.empty() )

    {

        sal_uInt32 nNamespace = rEntity.maNamespaceCount.top();

        while( nNamespace-- )

            if( rEntity.maNamespaceDefines[nNamespace].maPrefix == rPrefix )

                return rEntity.maNamespaceDefines[nNamespace].maNamespaceURL;

    }

    throw SAXException("No namespace defined for " + OUString::fromUtf8(rPrefix),

            Reference< XInterface >(), Any());

}

sal_Int32 FastSaxParserImpl::GetTokenWithContextNamespace( sal_Int32 nNamespaceToken, const xmlChar* pName )

{

    if( nNamespaceToken != FastToken::DONTKNOW )

    {

        sal_Int32 nNameToken = GetToken( pName );

        if( nNameToken != FastToken::DONTKNOW )

            return nNamespaceToken | nNameToken;

    }

    return FastToken::DONTKNOW;

}

namespace

{

    class ParserCleanup

    {

    private:

        FastSaxParserImpl& m_rParser;

        Entity& m_rEntity;

        rtl::Reference<ParserThread> m_xParser;

    public:

        ParserCleanup(FastSaxParserImpl& rParser, Entity& rEntity)

            : m_rParser(rParser)

            , m_rEntity(rEntity)

        {

        }

        ~ParserCleanup()

        {

            if (m_rEntity.mpParser)

            {

                if (m_rEntity.mpParser->myDoc)

                    xmlFreeDoc(m_rEntity.mpParser->myDoc);

                xmlFreeParserCtxt(m_rEntity.mpParser);

            }

            joinThread();

            m_rParser.popEntity();

        }

        void setThread(const rtl::Reference<ParserThread> &xParser)

        {

            m_xParser = xParser;

        }

        void joinThread()

        {

            if (m_xParser.is())

            {

                rtl::Reference<ParserThread> xToJoin = m_xParser;

                m_xParser.clear();

                xToJoin->join();

            }

        }

    };

}

/***************

*

* parseStream does Parser-startup initializations. The FastSaxParser::parse() method does

* the file-specific initialization work. (During a parser run, external files may be opened)

*

****************/

void FastSaxParserImpl::parseStream(const InputSource& rStructSource)

{

    xmlInitParser();

    // Only one text at one time

    std::unique_lock guard( maMutex );

    pushEntity(maData, rStructSource);

    Entity& rEntity = getEntity();

    ParserCleanup aEnsureFree(*this, rEntity);

    // start the document

    if( rEntity.mxDocumentHandler.is() )

    {

        rEntity.mxDocumentHandler->setDocumentLocator( mxDocumentLocator );

        rEntity.mxDocumentHandler->startDocument();

    }

#ifdef EMSCRIPTEN

    rEntity.mbEnableThreads = false;

#else

    if (!getenv("SAX_DISABLE_THREADS") && !m_bDisableThreadedParser)

    {

        Reference<css::io::XSeekable> xSeekable(rEntity.maStructSource.aInputStream, UNO_QUERY);

        // available() is not __really__ relevant here, but leave it in as a heuristic for non-seekable streams

        rEntity.mbEnableThreads = (xSeekable.is() && xSeekable->getLength() > 10000)

                || (rEntity.maStructSource.aInputStream->available() > 10000);

    }

#endif

    if (rEntity.mbEnableThreads)

    {

        rtl::Reference<ParserThread> xParser = new ParserThread(this);

        xParser->launch();

        aEnsureFree.setThread(xParser);

        bool done = false;

        do {

            rEntity.maConsumeResume.wait();

            rEntity.maConsumeResume.reset();

            std::unique_lock aGuard(rEntity.maEventProtector);

            while (!rEntity.maPendingEvents.empty())

            {

                if (rEntity.maPendingEvents.size() <= Entity::mnEventLowWater)

                    rEntity.maProduceResume.set(); // start producer again

                EventList aEventList = std::move(rEntity.maPendingEvents.front());

                rEntity.maPendingEvents.pop();

                aGuard.unlock(); // unlock

                if (!consume(aEventList))

                    done = true;

                aGuard.lock(); // lock

                if ( rEntity.maPendingEvents.size() <= Entity::mnEventLowWater )

                {

                    aGuard.unlock();

                    for (auto& rEvent : aEventList.maEvents)

                    {

                        if (rEvent.mxAttributes.is())

                        {

                            rEvent.mxAttributes->clear();

                            if( rEntity.mxNamespaceHandler.is() )

                                rEvent.mxDeclAttributes->clear();

                        }

                        aEventList.mbIsAttributesEmpty = true;

                    }

                    aGuard.lock();

                }

                rEntity.maUsedEvents.push(std::move(aEventList));

            }

        } while (!done);

        aEnsureFree.joinThread();

        deleteUsedEvents();

        // callbacks used inside XML_Parse may have caught an exception No need

        // to lock maSavedExceptionMutex here because parser thread is joined.

        // coverity[missing_lock : SUPPRESS] 2024.6.1

        if( rEntity.maSavedException.hasValue() )

            rEntity.throwException( mxDocumentLocator, true );

    }

    else

    {

        parse();

    }

    // finish document

    if( rEntity.mxDocumentHandler.is() )

    {

        rEntity.mxDocumentHandler->endDocument();

    }

}

void FastSaxParserImpl::setFastDocumentHandler( const Reference< XFastDocumentHandler >& Handler )

{

    maData.mxDocumentHandler = Handler;

}

void FastSaxParserImpl::setTokenHandler( const Reference< XFastTokenHandler >& xHandler )

{

    assert( dynamic_cast< FastTokenHandlerBase *>( xHandler.get() ) && "we expect this handler to be a subclass of FastTokenHandlerBase" );

    maData.mxTokenHandler = dynamic_cast< FastTokenHandlerBase *>( xHandler.get() );

}

void FastSaxParserImpl::registerNamespace( const OUString& NamespaceURL, sal_Int32 NamespaceToken )

{

    if( NamespaceToken < FastToken::NAMESPACE )

        throw IllegalArgumentException("Invalid namespace token " + OUString::number(NamespaceToken), css::uno::Reference<css::uno::XInterface >(), 0);

    if( GetNamespaceToken( NamespaceURL ) == FastToken::DONTKNOW )

    {

        maNamespaceMap[ NamespaceURL ] = NamespaceToken;

        return;

    }

    throw IllegalArgumentException("namespace URL is already registered: " + NamespaceURL, css::uno::Reference<css::uno::XInterface >(), 0);

}

OUString const & FastSaxParserImpl::getNamespaceURL( std::u16string_view rPrefix )

{

    try

    {

        return GetNamespaceURL( OUStringToOString( rPrefix, RTL_TEXTENCODING_UTF8 ) );

    }

    catch (const Exception&)

    {

    }

    throw IllegalArgumentException();

}

void FastSaxParserImpl::setErrorHandler(const Reference< XErrorHandler > & Handler)

{

    maData.mxErrorHandler = Handler;

}

void FastSaxParserImpl::setNamespaceHandler( const Reference< XFastNamespaceHandler >& Handler )

{

    maData.mxNamespaceHandler = Handler;

}

void FastSaxParserImpl::setCustomEntityNames(

    const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>& replacements)

{

    m_Replacements.resize(replacements.size());

    for (size_t i = 0; i < replacements.size(); ++i)

    {

        m_Replacements[i].name = replacements[i].First;

        m_Replacements[i].replacement = replacements[i].Second;

    }

    if (m_Replacements.size() > 1)

        std::sort(m_Replacements.begin(), m_Replacements.end());

}

void FastSaxParserImpl::deleteUsedEvents()

{

    Entity& rEntity = getEntity();

    std::unique_lock aGuard(rEntity.maEventProtector);

    while (!rEntity.maUsedEvents.empty())

    {

        { // the block makes sure that aEventList is destructed outside the lock

            EventList aEventList = std::move(rEntity.maUsedEvents.front());

            rEntity.maUsedEvents.pop();

            aGuard.unlock(); // unlock

        }

        aGuard.lock(); // lock

    }

}

void FastSaxParserImpl::produce( bool bForceFlush )

{

    Entity& rEntity = getEntity();

    if (!(bForceFlush ||

        rEntity.mnProducedEventsSize >= Entity::mnEventListSize))

        return;

    std::unique_lock aGuard(rEntity.maEventProtector);

    while (rEntity.maPendingEvents.size() >= Entity::mnEventHighWater)

    { // pause parsing for a bit

        aGuard.unlock(); // unlock

        rEntity.maProduceResume.wait();

        rEntity.maProduceResume.reset();

        aGuard.lock(); // lock

    }

    rEntity.maPendingEvents.push(std::move(*rEntity.mxProducedEvents));

    aGuard.unlock(); // unlock

    rEntity.mxProducedEvents.reset();

    assert(!rEntity.mxProducedEvents);

    rEntity.maConsumeResume.set();

}

bool FastSaxParserImpl::consume(EventList& rEventList)

{

    Entity& rEntity = getEntity();

    rEventList.mbIsAttributesEmpty = false;

    for (auto& rEvent : rEventList.maEvents)

    {

        switch (rEvent.maType)

        {

            case CallbackType::START_ELEMENT: