/* -*- 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 <comphelper/string.hxx>

#include <o3tl/safeint.hxx>

#include <o3tl/string_view.hxx>

#include <tools/stream.hxx>

#include <tools/debug.hxx>

#include <tools/color.hxx>

#include <rtl/ustrbuf.hxx>

#include <rtl/character.hxx>

#include <rtl/tencinfo.h>

#include <sal/log.hxx>

#include <tools/tenccvt.hxx>

#include <tools/datetime.hxx>

#include <unotools/datetime.hxx>

#include <svl/inettype.hxx>

#include <svl/lngmisc.hxx>

#include <com/sun/star/beans/PropertyAttribute.hpp>

#include <com/sun/star/document/XDocumentProperties.hpp>

#include <svtools/parhtml.hxx>

#include <svtools/htmltokn.h>

#include <svtools/htmlkywd.hxx>

#include <utility>

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

const sal_Int32 MAX_LEN( 1024 );

const sal_Int32 MAX_ENTITY_LEN( 8 );

// Tables to convert option values into strings

// <INPUT TYPE=xxx>

HTMLOptionEnum<HTMLInputType> const aInputTypeOptEnums[] =

{

    { OOO_STRING_SVTOOLS_HTML_IT_text,      HTMLInputType::Text        },

    { OOO_STRING_SVTOOLS_HTML_IT_password,  HTMLInputType::Password    },

    { OOO_STRING_SVTOOLS_HTML_IT_checkbox,  HTMLInputType::Checkbox    },

    { OOO_STRING_SVTOOLS_HTML_IT_radio,     HTMLInputType::Radio       },

    { OOO_STRING_SVTOOLS_HTML_IT_range,     HTMLInputType::Range       },

    { OOO_STRING_SVTOOLS_HTML_IT_scribble,  HTMLInputType::Scribble    },

    { OOO_STRING_SVTOOLS_HTML_IT_file,      HTMLInputType::File        },

    { OOO_STRING_SVTOOLS_HTML_IT_hidden,    HTMLInputType::Hidden      },

    { OOO_STRING_SVTOOLS_HTML_IT_submit,    HTMLInputType::Submit      },

    { OOO_STRING_SVTOOLS_HTML_IT_image,     HTMLInputType::Image       },

    { OOO_STRING_SVTOOLS_HTML_IT_reset,     HTMLInputType::Reset       },

    { OOO_STRING_SVTOOLS_HTML_IT_button,    HTMLInputType::Button      },

    { nullptr,                              HTMLInputType(0)    }

};

// <TABLE FRAME=xxx>

HTMLOptionEnum<HTMLTableFrame> const aTableFrameOptEnums[] =

{

    { OOO_STRING_SVTOOLS_HTML_TF_void,    HTMLTableFrame::Void    },

    { OOO_STRING_SVTOOLS_HTML_TF_above,   HTMLTableFrame::Above   },

    { OOO_STRING_SVTOOLS_HTML_TF_below,   HTMLTableFrame::Below   },

    { OOO_STRING_SVTOOLS_HTML_TF_hsides,  HTMLTableFrame::HSides  },

    { OOO_STRING_SVTOOLS_HTML_TF_lhs,     HTMLTableFrame::LHS     },

    { OOO_STRING_SVTOOLS_HTML_TF_rhs,     HTMLTableFrame::RHS     },

    { OOO_STRING_SVTOOLS_HTML_TF_vsides,  HTMLTableFrame::VSides  },

    { OOO_STRING_SVTOOLS_HTML_TF_box,     HTMLTableFrame::Box     },

    { OOO_STRING_SVTOOLS_HTML_TF_border,  HTMLTableFrame::Box     },

    { nullptr,                            HTMLTableFrame(0) }

};

// <TABLE RULES=xxx>

HTMLOptionEnum<HTMLTableRules> const aTableRulesOptEnums[] =

{

    { OOO_STRING_SVTOOLS_HTML_TR_none,   HTMLTableRules::NONE      },

    { OOO_STRING_SVTOOLS_HTML_TR_groups, HTMLTableRules::Groups    },

    { OOO_STRING_SVTOOLS_HTML_TR_rows,   HTMLTableRules::Rows      },

    { OOO_STRING_SVTOOLS_HTML_TR_cols,   HTMLTableRules::Cols      },

    { OOO_STRING_SVTOOLS_HTML_TR_all,    HTMLTableRules::All       },

    { nullptr,                           HTMLTableRules(0) }

};

HTMLOption::HTMLOption( HtmlOptionId nTok, OUString _aToken,

                        OUString _aValue )

    : aValue(std::move(_aValue))

    , aToken(std::move(_aToken))

    , nToken( nTok )

{

    DBG_ASSERT( nToken>=HtmlOptionId::BOOL_START && nToken<HtmlOptionId::END,

        "HTMLOption: unknown token" );

}

sal_uInt32 HTMLOption::GetNumber() const

{

    DBG_ASSERT( (nToken>=HtmlOptionId::NUMBER_START &&

                 nToken<HtmlOptionId::NUMBER_END) ||

                (nToken>=HtmlOptionId::CONTEXT_START &&

                 nToken<HtmlOptionId::CONTEXT_END) ||

                nToken==HtmlOptionId::VALUE,

        "GetNumber: Option not numerical" );

    OUString aTmp(comphelper::string::stripStart(aValue, ' '));

    sal_Int32 nTmp = aTmp.toInt32();

    return nTmp >= 0 ? static_cast<sal_uInt32>(nTmp) : 0;

}

sal_Int32 HTMLOption::GetSNumber() const

{

    DBG_ASSERT( (nToken>=HtmlOptionId::NUMBER_START && nToken<HtmlOptionId::NUMBER_END) ||

                (nToken>=HtmlOptionId::CONTEXT_START && nToken<HtmlOptionId::CONTEXT_END),

        "GetSNumber: Option not numerical" );

    OUString aTmp(comphelper::string::stripStart(aValue, ' '));

    return aTmp.toInt32();

}

void HTMLOption::GetNumbers( std::vector<sal_uInt32> &rNumbers ) const

{

    rNumbers.clear();

    // This is a very simplified scanner: it only searches all

    // numerals in the string.

    bool bInNum = false;

    sal_uInt32 nNum = 0;

    for( sal_Int32 i=0; i<aValue.getLength(); i++ )

    {

        sal_Unicode c = aValue[ i ];

        if( c>='0' && c<='9' )

        {

            nNum *= 10;

            nNum += (c - '0');

            bInNum = true;

        }

        else if( bInNum )

        {

            rNumbers.push_back( nNum );

            bInNum = false;

            nNum = 0;

        }

    }

    if( bInNum )

    {

        rNumbers.push_back( nNum );

    }

}

void HTMLOption::GetColor( Color& rColor ) const

{

    DBG_ASSERT( (nToken>=HtmlOptionId::COLOR_START && nToken<HtmlOptionId::COLOR_END) || nToken==HtmlOptionId::SIZE,

        "GetColor: Option is not a color." );

    OUString aTmp(aValue.toAsciiLowerCase());

    sal_uInt32 nColor = SAL_MAX_UINT32;

    if (!aTmp.isEmpty() && aTmp[0] != '#')

        nColor = GetHTMLColor(aTmp);

    if( SAL_MAX_UINT32 == nColor )

    {

        nColor = 0;

        sal_Int32 nPos = 0;

        for (sal_uInt32 i=0; i<6; ++i)

        {

            // Whatever Netscape does to get color values,

            // at maximum three characters < '0' are ignored.

            sal_Unicode c = nPos<aTmp.getLength() ? aTmp[ nPos++ ] : '0';

            if( c < '0' )

            {

                c = nPos<aTmp.getLength() ? aTmp[nPos++] : '0';

                if( c < '0' )

                    c = nPos<aTmp.getLength() ? aTmp[nPos++] : '0';

            }

            nColor *= 16;

            if( c >= '0' && c <= '9' )

                nColor += (c - '0');

            else if( c >= 'a' && c <= 'f' )

                nColor += (c + 0xa - 'a');

        }

    }

    rColor.SetRed(   static_cast<sal_uInt8>((nColor & 0x00ff0000) >> 16) );

    rColor.SetGreen( static_cast<sal_uInt8>((nColor & 0x0000ff00) >> 8));

    rColor.SetBlue(  static_cast<sal_uInt8>(nColor & 0x000000ff) );

}

HTMLInputType HTMLOption::GetInputType() const

{

    DBG_ASSERT( nToken==HtmlOptionId::TYPE, "GetInputType: Option not TYPE" );

    return GetEnum( aInputTypeOptEnums, HTMLInputType::Text );

}

HTMLTableFrame HTMLOption::GetTableFrame() const

{

    DBG_ASSERT( nToken==HtmlOptionId::FRAME, "GetTableFrame: Option not FRAME" );

    return GetEnum( aTableFrameOptEnums );

}

HTMLTableRules HTMLOption::GetTableRules() const

{

    DBG_ASSERT( nToken==HtmlOptionId::RULES, "GetTableRules: Option not RULES" );

    return GetEnum( aTableRulesOptEnums );

}

HTMLParser::HTMLParser( SvStream& rIn, bool bReadNewDoc ) :

    SvParser<HtmlTokenId>( rIn ),

    bNewDoc(bReadNewDoc),

    bIsInHeader(true),

    bReadListing(false),

    bReadXMP(false),

    bReadPRE(false),

    bReadTextArea(false),

    bReadScript(false),

    bReadStyle(false),

    bEndTokenFound(false),

    bPre_IgnoreNewPara(false),

    bReadNextChar(false),

    bReadComment(false),

    nPre_LinePos(0),

    mnPendingOffToken(HtmlTokenId::NONE)

{

    //#i76649, default to UTF-8 for HTML unless we know differently

    SetSrcEncoding(RTL_TEXTENCODING_UTF8);

}

HTMLParser::~HTMLParser()

{

}

void HTMLParser::SetNamespace(std::u16string_view rNamespace)

{

    // Convert namespace alias to a prefix.

    maNamespace = OUString::Concat(rNamespace) + ":";

}

namespace

{

    class RefGuard

    {

    private:

        HTMLParser& m_rParser;

    public:

        RefGuard(HTMLParser& rParser)

            : m_rParser(rParser)

        {

            m_rParser.AddFirstRef();

        }

        ~RefGuard()

        {

            if (m_rParser.GetStatus() != SvParserState::Pending)

                m_rParser.ReleaseRef(); // Parser not needed anymore

        }

    };

}

SvParserState HTMLParser::CallParser()

{

    eState = SvParserState::Working;

    nNextCh = GetNextChar();

    SaveState( HtmlTokenId::NONE );

    nPre_LinePos = 0;

    bPre_IgnoreNewPara = false;

    RefGuard aRefGuard(*this);

    Continue( HtmlTokenId::NONE );

    return eState;

}

void HTMLParser::Continue( HtmlTokenId nToken )

{

    if( nToken == HtmlTokenId::NONE )

        nToken = GetNextToken();

    while( IsParserWorking() )

    {

        SaveState( nToken );

        nToken = FilterToken( nToken );

        if( nToken != HtmlTokenId::NONE )

            NextToken( nToken );

        if( IsParserWorking() )

            SaveState( HtmlTokenId::NONE );         // continue with new token

        nToken = GetNextToken();

    }

}

HtmlTokenId HTMLParser::FilterToken( HtmlTokenId nToken )

{

    switch( nToken )

    {

    case HtmlTokenId(EOF):

        nToken = HtmlTokenId::NONE;

        break;          // don't pass

    case HtmlTokenId::HEAD_OFF:

        bIsInHeader = false;

        break;

    case HtmlTokenId::HEAD_ON:

        bIsInHeader = true;

        break;

    case HtmlTokenId::BODY_ON:

        bIsInHeader = false;

        break;

    case HtmlTokenId::FRAMESET_ON:

        bIsInHeader = false;

        break;

    case HtmlTokenId::BODY_OFF:

        bReadPRE = bReadListing = bReadXMP = false;

        break;

    case HtmlTokenId::HTML_OFF:

        nToken = HtmlTokenId::NONE;

        bReadPRE = bReadListing = bReadXMP = false;

        break;      // HtmlTokenId::ON hasn't been passed either !

    case HtmlTokenId::PREFORMTXT_ON:

        StartPRE();

        break;

    case HtmlTokenId::PREFORMTXT_OFF:

        FinishPRE();

        break;

    case HtmlTokenId::LISTING_ON:

        StartListing();

        break;

    case HtmlTokenId::LISTING_OFF:

        FinishListing();

        break;

    case HtmlTokenId::XMP_ON:

        StartXMP();

        break;

    case HtmlTokenId::XMP_OFF:

        FinishXMP();

        break;

    default:

        if( bReadPRE )

            nToken = FilterPRE( nToken );

        else if( bReadListing )

            nToken = FilterListing( nToken );

        else if( bReadXMP )

            nToken = FilterXMP( nToken );

        break;

    }

    return nToken;

}

namespace {

constexpr bool HTML_ISPRINTABLE(sal_Unicode c) { return c >= 32 && c != 127; }

constexpr bool HTML_ISSPACE(sal_uInt32 c)

{

    return ' ' == c || '\t' == c || '\r' == c || '\n' == c || '\x0b' == c;

}

}

HtmlTokenId HTMLParser::ScanText(const sal_Unicode cBreak)

{

    OUStringBuffer sTmpBuffer( MAX_LEN );

    bool bContinue = true;

    bool bEqSignFound = false;

    sal_uInt32  cQuote = 0U;

    while( bContinue && IsParserWorking() )

    {

        bool bNextCh = true;

        switch( nNextCh )

        {

        case '&':

            bEqSignFound = false;

            if( bReadXMP )

                sTmpBuffer.append( '&' );

            else

            {

                sal_uInt64 nStreamPos = rInput.Tell();

                sal_uInt32 nLinePos = GetLinePos();

                sal_uInt32 cChar = 0U;

                if( '#' == (nNextCh = GetNextChar()) )

                {

                    nNextCh = GetNextChar();

                    const bool bIsHex( 'x' == nNextCh );

                    const bool bIsDecOrHex( bIsHex || rtl::isAsciiDigit(nNextCh) );

                    if ( bIsDecOrHex )

                    {

                        if ( bIsHex )

                        {

                            nNextCh = GetNextChar();

                            while ( rtl::isAsciiHexDigit(nNextCh) )

                            {

                                cChar = cChar * 16U +

                                        ( nNextCh <= '9'

                                          ? sal_uInt32( nNextCh - '0' )

                                          : ( nNextCh <= 'F'

                                              ? sal_uInt32( nNextCh - 'A' + 10 )

                                              : sal_uInt32( nNextCh - 'a' + 10 ) ) );

                                nNextCh = GetNextChar();

                            }

                        }

                        else

                        {

                            do

                            {

                                cChar = cChar * 10U + sal_uInt32( nNextCh - '0');

                                nNextCh = GetNextChar();

                            }

                            while( rtl::isAsciiDigit(nNextCh) );

                        }

                        if( RTL_TEXTENCODING_DONTKNOW != eSrcEnc &&

                            RTL_TEXTENCODING_UCS2 != eSrcEnc &&

                            RTL_TEXTENCODING_UTF8 != eSrcEnc &&

                            cChar < 256 )

                        {

                            const sal_uInt32 convertFlags =

                                RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT |

                                RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |

                                RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT;

                            char cEncodedChar = static_cast<char>(cChar);

                            cChar = OUString(&cEncodedChar, 1, eSrcEnc, convertFlags).toChar();

                            if( 0U == cChar )

                            {

                                // If the character could not be

                                // converted, because a conversion is not

                                // available, do no conversion at all.

                                cChar = cEncodedChar;

                            }

                        }

                    }

                    else

                        nNextCh = 0U;

                    if (!rtl::isUnicodeCodePoint(cChar)

                        || (linguistic::IsControlChar(cChar)

                            && cChar != '\r' && cChar != '\n' && cChar != '\t'))

                    {

                        cChar = '?';

                    }

                }

                else if( rtl::isAsciiAlpha( nNextCh ) )

                {

                    OUStringBuffer sEntityBuffer( MAX_ENTITY_LEN );

                    sal_Int32 nPos = 0;

                    do

                    {

                        sEntityBuffer.appendUtf32( nNextCh );

                        nPos++;

                        nNextCh = GetNextChar();

                    }

                    while( nPos < MAX_ENTITY_LEN && rtl::isAsciiAlphanumeric( nNextCh ) &&

                           !rInput.eof() );

                    if( IsParserWorking() && !rInput.eof() )

                    {

                        std::u16string_view sEntity(sEntityBuffer.subView(0, nPos));

                        cChar = GetHTMLCharName( sEntity );

                        // not found ( == 0 ): plain text

                        // or a character which is inserted as attribute

                        if( 0U == cChar && ';' != nNextCh )

                        {

                            DBG_ASSERT( rInput.Tell() - nStreamPos ==

                                        static_cast<sal_uInt64>(nPos+1)*GetCharSize(),

                                        "UTF-8 is failing here" );

                            for( sal_Int32 i = nPos-1; i>1; i-- )

                            {

                                nNextCh = sEntityBuffer[i];

                                sEntityBuffer.setLength( i );

                                sEntity = sEntityBuffer.subView(0, i);

                                cChar = GetHTMLCharName( sEntity );

                                if( cChar )

                                {

                                    rInput.SeekRel( -static_cast<sal_Int64>

                                            (nPos-i)*GetCharSize() );

                                    nlLinePos -= sal_uInt32(nPos-i);

                                    nPos = i;

                                    ClearTxtConvContext();

                                    break;

                                }

                            }

                        }

                        if( !cChar )        // unknown character?

                        {

                            // back in stream, insert '&'

                            // and restart with next character

                            sTmpBuffer.append( '&' );

                            DBG_ASSERT( rInput.Tell()-nStreamPos ==

                                        static_cast<sal_uInt64>(nPos+1)*GetCharSize(),

                                        "Wrong stream position" );

                            DBG_ASSERT( nlLinePos-nLinePos ==

                                        static_cast<sal_uInt32>(nPos+1),

                                        "Wrong line position" );

                            rInput.Seek( nStreamPos );

                            nlLinePos = nLinePos;

                            ClearTxtConvContext();

                            break;

                        }

                        assert(cChar != 0);

                        // 1 == Non Breaking Space

                        // 2 == SoftHyphen

                        if (cChar == 1 || cChar == 2)

                        {

                            if( '>' == cBreak )

                            {

                                // When reading the content of a tag we have

                                // to change it to ' ' or '-'

                                if( 1U == cChar )

                                    cChar = ' ';

                                else //2U

                                    cChar = '-';

                            }

                            else

                            {

                                // If not scanning a tag return token

                                aToken.append( sTmpBuffer );

                                sTmpBuffer.setLength(0);

                                if( !aToken.isEmpty() )

                                {

                                    // restart with character

                                    nNextCh = '&';

                                    DBG_ASSERT( rInput.Tell()-nStreamPos ==

                                                static_cast<sal_uInt64>(nPos+1)*GetCharSize(),

                                                "Wrong stream position" );

                                    DBG_ASSERT( nlLinePos-nLinePos ==

                                                static_cast<sal_uInt32>(nPos+1),

                                                "Wrong line position" );

                                    rInput.Seek( nStreamPos );

                                    nlLinePos = nLinePos;

                                    ClearTxtConvContext();

                                    return HtmlTokenId::TEXTTOKEN;

                                }

                                // Hack: _GetNextChar shall not read the

                                // next character

                                if( ';' != nNextCh )

                                    aToken.append( " " );

                                if( 1U == cChar )

                                    return HtmlTokenId::NONBREAKSPACE;

                                else //2U

                                    return HtmlTokenId::SOFTHYPH;

                            }

                        }

                    }

                    else

                        nNextCh = 0U;

                }

                // &{...};-JavaScript-Macros are not supported any longer.

                else if( IsParserWorking() )

                {

                    sTmpBuffer.append( '&' );

                    bNextCh = false;

                    break;

                }

                bNextCh = (';' == nNextCh);

                if( cBreak=='>' && (cChar=='\\' || cChar=='\'' ||

                                    cChar=='\"' || cChar==' ') )

                {

                    // ' and " have to be escaped within tags to separate

                    // them from ' and " enclosing options.

                    // \ has to be escaped as well.

                    // Space is protected because it's not a delimiter between

                    // options.

                    sTmpBuffer.append( '\\' );

                }

                if( IsParserWorking() )

                {

                    if( cChar )

                        sTmpBuffer.appendUtf32( cChar );

                }

                else if( SvParserState::Pending==eState && '>'!=cBreak )

                {

                    // Restart with '&', the remainder is returned as

                    // text token.

                    if( !aToken.isEmpty() || !sTmpBuffer.isEmpty() )

                    {

                        // _GetNextChar() returns the previous text and

                        // during the next execution a new character is read.

                        // Thus we have to position in front of the '&'.

                        nNextCh = 0U;

                        rInput.Seek( nStreamPos - GetCharSize() );

                        nlLinePos = nLinePos-1;

                        ClearTxtConvContext();

                        bReadNextChar = true;

                    }

                    bNextCh = false;

                }

            }

            break;

        case '=':

            if( '>'==cBreak && !cQuote )

                bEqSignFound = true;

            sTmpBuffer.appendUtf32( nNextCh );

            break;

        case '\\':

            if( '>'==cBreak )

            {

                // mark within tags

                sTmpBuffer.append( '\\' );

            }

            sTmpBuffer.append( '\\' );

            break;

        case '\"':

        case '\'':

            if( '>'==cBreak )

            {

                if( bEqSignFound )

                    cQuote = nNextCh;

                else if( cQuote && (cQuote==nNextCh ) )

                    cQuote = 0U;

            }

            sTmpBuffer.appendUtf32( nNextCh );

            bEqSignFound = false;

            break;

        case sal_Unicode(EOF):

            if( rInput.eof() )

            {

                bContinue = false;

            }

            // else: ignore, not a valid code point

            break;

        case '<':

            bEqSignFound = false;

            if( '>'==cBreak )

                sTmpBuffer.appendUtf32( nNextCh );

            else

                bContinue = false;      // break, string is together

            break;

        case '\f':

            if( '>' == cBreak )

            {

                // If scanning options treat it like a space, ...

                sTmpBuffer.append( ' ' );

            }

            else

            {

                // otherwise it's a separate token.

                bContinue = false;

            }

            break;

        case '\r':

        case '\n':

            if( '>'==cBreak )

            {

                // cr/lf in tag is handled in GetNextToken_()

                sTmpBuffer.appendUtf32( nNextCh );

                break;

            }

            else if( bReadListing || bReadXMP || bReadPRE || bReadTextArea )

            {

                bContinue = false;

                break;

            }

            // Reduce sequence of CR/LF/BLANK/TAB to a single blank

            [[fallthrough]];

        case '\t':

            if( '\t'==nNextCh && bReadPRE && '>'!=cBreak )

            {

                // Pass Tabs up in <PRE>

                bContinue = false;

                break;

            }

            [[fallthrough]];

        case '\x0b':

            if( '\x0b'==nNextCh && (bReadPRE || bReadXMP ||bReadListing) &&

                '>'!=cBreak )

            {

                break;

            }

            if (!m_bPreserveSpaces)

                nNextCh = ' ';

            [[fallthrough]];

        case ' ':

            if (!m_bPreserveSpaces)

            {

                sTmpBuffer.appendUtf32(nNextCh);

                if ('>' != cBreak && (!bReadListing && !bReadXMP && !bReadPRE && !bReadTextArea))

                {

                    // Reduce sequences of Blanks/Tabs/CR/LF to a single blank

                    do

                    {

                        nNextCh = GetNextChar();

                        if (sal_Unicode(EOF) == nNextCh && rInput.eof())

                        {

                            if (!aToken.isEmpty() || sTmpBuffer.getLength() > 1)

                            {

                                // Have seen s.th. aside from blanks?

                                aToken.append(sTmpBuffer);

                                sTmpBuffer.setLength(0);

                                return HtmlTokenId::TEXTTOKEN;

                            }

                            else

                                // Only read blanks: no text must be returned

                                // and GetNextToken_ has to read until EOF

                                return HtmlTokenId::NONE;

                        }

                    } while (HTML_ISSPACE(nNextCh));

                    bNextCh = false;

                }

                break;

            }

            [[fallthrough]];

        default:

            bEqSignFound = false;

            if (nNextCh == cBreak && !cQuote)

                bContinue = false;

            else

            {

                do {

                    if (!linguistic::IsControlChar(nNextCh) || HTML_ISSPACE(nNextCh))

                    {

                    // All remaining characters make their way into the text.

                        sTmpBuffer.appendUtf32( nNextCh );

                    }

                    nNextCh = GetNextChar();

                    if( ( sal_Unicode(EOF) == nNextCh && rInput.eof() ) ||

                        !IsParserWorking() )

                    {

                        if( !sTmpBuffer.isEmpty() )

                            aToken.append( sTmpBuffer );

                        return HtmlTokenId::TEXTTOKEN;

                    }

                } while( rtl::isAsciiAlpha( nNextCh ) || rtl::isAsciiDigit( nNextCh ) );

                bNextCh = false;

            }

        }

        if( bContinue && bNextCh )

            nNextCh = GetNextChar();

    }

    if( !sTmpBuffer.isEmpty() )

        aToken.append( sTmpBuffer );

    return HtmlTokenId::TEXTTOKEN;

}

HtmlTokenId HTMLParser::GetNextRawToken()

{

    OUStringBuffer sTmpBuffer( MAX_LEN );

    if( bEndTokenFound )

    {

        // During the last execution we already found the end token,

        // thus we don't have to search it again.

        bReadScript = false;

        bReadStyle = false;

        aEndToken.clear();

        bEndTokenFound = false;

        return HtmlTokenId::NONE;

    }

    // Default return value: HtmlTokenId::RAWDATA

    bool bContinue = true;

    HtmlTokenId nToken = HtmlTokenId::RAWDATA;

    SaveState( HtmlTokenId::NONE );

    while( bContinue && IsParserWorking() )

    {

        bool bNextCh = true;

        switch( nNextCh )

        {

        case '<':

            {

                // Maybe we've reached the end.

                // Save what we have read previously...

                aToken.append( sTmpBuffer );

                sTmpBuffer.setLength(0);

                // and remember position in stream.

                sal_uInt64 nStreamPos = rInput.Tell();

                sal_uInt32 nLineNr = GetLineNr();

                sal_uInt32 nLinePos = GetLinePos();

                // Start of an end token?

                bool bOffState = false;

                if( '/' == (nNextCh = GetNextChar()) )

                {

                    bOffState = true;

                    nNextCh = GetNextChar();

                }

                else if( '!' == nNextCh )

                {

                    sTmpBuffer.appendUtf32( nNextCh );

                    nNextCh = GetNextChar();

                }

                // Read following letters

                while( (rtl::isAsciiAlpha(nNextCh) || '-'==nNextCh) &&

                       IsParserWorking() && sTmpBuffer.getLength() < MAX_LEN )

                {

                    sTmpBuffer.appendUtf32( nNextCh );

                    nNextCh = GetNextChar();

                }

                OUString aTok( sTmpBuffer.toString() );

                aTok = aTok.toAsciiLowerCase();

                bool bDone = false;

                if( bReadScript || !aEndToken.isEmpty() )

                {

                    if( !bReadComment )

                    {

                        if( aTok.startsWith( OOO_STRING_SVTOOLS_HTML_comment ) )

                        {

                            bReadComment = true;

                        }

                        else

                        {

                            // A script has to end with "</SCRIPT>". But

                            // ">" is optional for security reasons

                            bDone = bOffState &&

                            ( bReadScript

                                ? aTok == OOO_STRING_SVTOOLS_HTML_script

                                : aTok == aEndToken );

                        }

                    }

                    if( bReadComment && '>'==nNextCh && aTok.endsWith( "--" ) )

                    {

                        // End of comment of style <!----->

                        bReadComment = false;

                    }

                }

                else

                {

                    // Style sheets can be closed by </STYLE>, </HEAD> or <BODY>

                    if( bOffState )

                        bDone = aTok == OOO_STRING_SVTOOLS_HTML_style ||

                                aTok == OOO_STRING_SVTOOLS_HTML_head;

                    else

                        bDone = aTok == OOO_STRING_SVTOOLS_HTML_body;

                }

                if( bDone )

                {

                    // Done! Return the previously read string (if requested)

                    // and continue.

                    bContinue = false;

                    // nToken==0 means, GetNextToken_ continues to read

                    if( aToken.isEmpty() && (bReadStyle || bReadScript) )

                    {

                        // Immediately close environment (or context?)

                        // and parse the end token

                        bReadScript = false;

                        bReadStyle = false;

                        aEndToken.clear();

                        nToken = HtmlTokenId::NONE;

                    }

                    else

                    {

                        // Keep bReadScript/bReadStyle alive

                        // and parse end token during next execution

                        bEndTokenFound = true;

                    }

                    // Move backwards in stream to '<'

                    rInput.Seek( nStreamPos );

                    SetLineNr( nLineNr );

                    SetLinePos( nLinePos );

                    ClearTxtConvContext();

                    nNextCh = '<';

                    // Don't append string to token.

                    sTmpBuffer.setLength( 0 );

                }

                else

                {

                    // remember "</" , everything else we find in the buffer

                    aToken.append( "<" );

                    if( bOffState )

                        aToken.append( "/" );

                    bNextCh = false;

                }

            }

            break;

        case '-':

            sTmpBuffer.appendUtf32( nNextCh );

            if( bReadComment )

            {

                bool bTwoMinus = false;

                nNextCh = GetNextChar();

                while( '-' == nNextCh && IsParserWorking() )

                {

                    bTwoMinus = true;

                    sTmpBuffer.appendUtf32( nNextCh );

                    nNextCh = GetNextChar();

                }

                if( '>' == nNextCh && IsParserWorking() && bTwoMinus )

                    bReadComment = false;

                bNextCh = false;

            }

            break;

        case '\r':

            // \r\n? closes the current text token (even if it's empty)

            nNextCh = GetNextChar();

            if( nNextCh=='\n' )

                nNextCh = GetNextChar();

            bContinue = false;

            break;

        case '\n':

            // \n closes the current text token (even if it's empty)

            nNextCh = GetNextChar();

            bContinue = false;

            break;

        case sal_Unicode(EOF):

            // eof closes the current text token and behaves like having read

            // an end token

            if( rInput.eof() )

            {

                bContinue = false;

                if( !aToken.isEmpty() || !sTmpBuffer.isEmpty() )

                {

                    bEndTokenFound = true;

                }

                else

                {

                    bReadScript = false;

                    bReadStyle = false;

                    aEndToken.clear();

                    nToken = HtmlTokenId::NONE;

                }

            }

            break;

        default:

            if (!linguistic::IsControlChar(nNextCh) || nNextCh == '\t')

            {

                // all remaining characters are appended to the buffer

                sTmpBuffer.appendUtf32( nNextCh );

            }

            break;

        }

        if( !bContinue && !sTmpBuffer.isEmpty() )

        {

            aToken.append( sTmpBuffer );

            sTmpBuffer.setLength(0);

        }

        if( bContinue && bNextCh )

            nNextCh = GetNextChar();

    }

    if( IsParserWorking() )

        SaveState( HtmlTokenId::NONE );

    else

        nToken = HtmlTokenId::NONE;

    return nToken;

}

// Scan next token

HtmlTokenId HTMLParser::GetNextToken_()

{

    HtmlTokenId nRet = HtmlTokenId::NONE;

    sSaveToken.clear();

    if (mnPendingOffToken != HtmlTokenId::NONE)

    {

        // HtmlTokenId::<TOKEN>_OFF generated for HtmlTokenId::<TOKEN>_ON

        nRet = mnPendingOffToken;

        mnPendingOffToken = HtmlTokenId::NONE;

        aToken.setLength( 0 );

        return nRet;

    }

    // Delete options

    maOptions.clear();

    if( !IsParserWorking() )        // Don't continue if already an error occurred

        return HtmlTokenId::NONE;

    bool bReadNextCharSave = bReadNextChar;

    if( bReadNextChar )

    {

        DBG_ASSERT( !bEndTokenFound,

                    "Read a character despite </SCRIPT> was read?" );

        nNextCh = GetNextChar();

        if( !IsParserWorking() )        // Don't continue if already an error occurred

            return HtmlTokenId::NONE;

        bReadNextChar = false;