| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svtools.hxx" |
| |
| #include <ctype.h> |
| #include <stdio.h> |
| #include <tools/stream.hxx> |
| #include <tools/debug.hxx> |
| #include <tools/color.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/strbuf.hxx> |
| #ifndef _SVSTDARR_HXX |
| #define _SVSTDARR_ULONGS |
| #include <svl/svstdarr.hxx> |
| #endif |
| |
| #include <tools/tenccvt.hxx> |
| #include <tools/datetime.hxx> |
| #include <svl/inettype.hxx> |
| #include <comphelper/string.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> |
| |
| |
| using namespace ::com::sun::star; |
| |
| |
| const sal_Int32 MAX_LEN( 1024L ); |
| //static sal_Unicode sTmpBuffer[ MAX_LEN+1 ]; |
| const sal_Int32 MAX_MACRO_LEN( 1024 ); |
| |
| const sal_Int32 MAX_ENTITY_LEN( 8L ); |
| |
| /* */ |
| |
| // Tabellen zum Umwandeln von Options-Werten in Strings |
| |
| // <INPUT TYPE=xxx> |
| static HTMLOptionEnum __READONLY_DATA aInputTypeOptEnums[] = |
| { |
| { OOO_STRING_SVTOOLS_HTML_IT_text, HTML_IT_TEXT }, |
| { OOO_STRING_SVTOOLS_HTML_IT_password, HTML_IT_PASSWORD }, |
| { OOO_STRING_SVTOOLS_HTML_IT_checkbox, HTML_IT_CHECKBOX }, |
| { OOO_STRING_SVTOOLS_HTML_IT_radio, HTML_IT_RADIO }, |
| { OOO_STRING_SVTOOLS_HTML_IT_range, HTML_IT_RANGE }, |
| { OOO_STRING_SVTOOLS_HTML_IT_scribble, HTML_IT_SCRIBBLE }, |
| { OOO_STRING_SVTOOLS_HTML_IT_file, HTML_IT_FILE }, |
| { OOO_STRING_SVTOOLS_HTML_IT_hidden, HTML_IT_HIDDEN }, |
| { OOO_STRING_SVTOOLS_HTML_IT_submit, HTML_IT_SUBMIT }, |
| { OOO_STRING_SVTOOLS_HTML_IT_image, HTML_IT_IMAGE }, |
| { OOO_STRING_SVTOOLS_HTML_IT_reset, HTML_IT_RESET }, |
| { OOO_STRING_SVTOOLS_HTML_IT_button, HTML_IT_BUTTON }, |
| { 0, 0 } |
| }; |
| |
| // <TABLE FRAME=xxx> |
| static HTMLOptionEnum __READONLY_DATA aTableFrameOptEnums[] = |
| { |
| { OOO_STRING_SVTOOLS_HTML_TF_void, HTML_TF_VOID }, |
| { OOO_STRING_SVTOOLS_HTML_TF_above, HTML_TF_ABOVE }, |
| { OOO_STRING_SVTOOLS_HTML_TF_below, HTML_TF_BELOW }, |
| { OOO_STRING_SVTOOLS_HTML_TF_hsides, HTML_TF_HSIDES }, |
| { OOO_STRING_SVTOOLS_HTML_TF_lhs, HTML_TF_LHS }, |
| { OOO_STRING_SVTOOLS_HTML_TF_rhs, HTML_TF_RHS }, |
| { OOO_STRING_SVTOOLS_HTML_TF_vsides, HTML_TF_VSIDES }, |
| { OOO_STRING_SVTOOLS_HTML_TF_box, HTML_TF_BOX }, |
| { OOO_STRING_SVTOOLS_HTML_TF_border, HTML_TF_BOX }, |
| { 0, 0 } |
| }; |
| |
| // <TABLE RULES=xxx> |
| static HTMLOptionEnum __READONLY_DATA aTableRulesOptEnums[] = |
| { |
| { OOO_STRING_SVTOOLS_HTML_TR_none, HTML_TR_NONE }, |
| { OOO_STRING_SVTOOLS_HTML_TR_groups, HTML_TR_GROUPS }, |
| { OOO_STRING_SVTOOLS_HTML_TR_rows, HTML_TR_ROWS }, |
| { OOO_STRING_SVTOOLS_HTML_TR_cols, HTML_TR_COLS }, |
| { OOO_STRING_SVTOOLS_HTML_TR_all, HTML_TR_ALL }, |
| { 0, 0 } |
| }; |
| |
| |
| SV_IMPL_PTRARR(HTMLOptions,HTMLOptionPtr) |
| |
| /* */ |
| |
| sal_uInt16 HTMLOption::GetEnum( const HTMLOptionEnum *pOptEnums, sal_uInt16 nDflt ) const |
| { |
| sal_uInt16 nValue = nDflt; |
| |
| while( pOptEnums->pName ) |
| if( aValue.EqualsIgnoreCaseAscii( pOptEnums->pName ) ) |
| break; |
| else |
| pOptEnums++; |
| |
| if( pOptEnums->pName ) |
| nValue = pOptEnums->nValue; |
| |
| return nValue; |
| } |
| |
| sal_Bool HTMLOption::GetEnum( sal_uInt16 &rEnum, const HTMLOptionEnum *pOptEnums ) const |
| { |
| while( pOptEnums->pName ) |
| { |
| if( aValue.EqualsIgnoreCaseAscii( pOptEnums->pName ) ) |
| break; |
| else |
| pOptEnums++; |
| } |
| |
| const sal_Char *pName = pOptEnums->pName; |
| if( pName ) |
| rEnum = pOptEnums->nValue; |
| |
| return (pName != 0); |
| } |
| |
| HTMLOption::HTMLOption( sal_uInt16 nTok, const String& rToken, |
| const String& rValue ) |
| : aValue(rValue) |
| , aToken(rToken) |
| , nToken( nTok ) |
| { |
| DBG_ASSERT( nToken>=HTML_OPTION_START && nToken<HTML_OPTION_END, |
| "HTMLOption: unbekanntes Token" ); |
| } |
| |
| sal_uInt32 HTMLOption::GetNumber() const |
| { |
| DBG_ASSERT( (nToken>=HTML_OPTION_NUMBER_START && |
| nToken<HTML_OPTION_NUMBER_END) || |
| (nToken>=HTML_OPTION_CONTEXT_START && |
| nToken<HTML_OPTION_CONTEXT_END) || |
| nToken==HTML_O_VALUE, |
| "GetNumber: Option ist nicht numerisch" ); |
| String aTmp( aValue ); |
| aTmp.EraseLeadingChars(); |
| sal_Int32 nTmp = aTmp.ToInt32(); |
| return nTmp >= 0 ? (sal_uInt32)nTmp : 0; |
| } |
| |
| sal_Int32 HTMLOption::GetSNumber() const |
| { |
| DBG_ASSERT( (nToken>=HTML_OPTION_NUMBER_START && nToken<HTML_OPTION_NUMBER_END) || |
| (nToken>=HTML_OPTION_CONTEXT_START && nToken<HTML_OPTION_CONTEXT_END), |
| "GetSNumber: Option ist nicht numerisch" ); |
| String aTmp( aValue ); |
| aTmp.EraseLeadingChars(); |
| return aTmp.ToInt32(); |
| } |
| |
| void HTMLOption::GetNumbers( SvULongs &rLongs, sal_Bool bSpaceDelim ) const |
| { |
| if( rLongs.Count() ) |
| rLongs.Remove( 0, rLongs.Count() ); |
| |
| if( bSpaceDelim ) |
| { |
| // das ist ein sehr stark vereinfachter Scanner. Er sucht einfach |
| // alle Tiffern aus dem String |
| sal_Bool bInNum = sal_False; |
| sal_uLong nNum = 0; |
| for( xub_StrLen i=0; i<aValue.Len(); i++ ) |
| { |
| register sal_Unicode c = aValue.GetChar( i ); |
| if( c>='0' && c<='9' ) |
| { |
| nNum *= 10; |
| nNum += (c - '0'); |
| bInNum = sal_True; |
| } |
| else if( bInNum ) |
| { |
| rLongs.Insert( nNum, rLongs.Count() ); |
| bInNum = sal_False; |
| nNum = 0; |
| } |
| } |
| if( bInNum ) |
| { |
| rLongs.Insert( nNum, rLongs.Count() ); |
| } |
| } |
| else |
| { |
| // hier wird auf die korrekte Trennung der Zahlen durch ',' geachtet |
| // und auch mal eine 0 eingefuegt |
| xub_StrLen nPos = 0; |
| while( nPos < aValue.Len() ) |
| { |
| register sal_Unicode c; |
| while( nPos < aValue.Len() && |
| ((c=aValue.GetChar(nPos)) == ' ' || c == '\t' || |
| c == '\n' || c== '\r' ) ) |
| nPos++; |
| |
| if( nPos==aValue.Len() ) |
| rLongs.Insert( sal_uLong(0), rLongs.Count() ); |
| else |
| { |
| xub_StrLen nEnd = aValue.Search( (sal_Unicode)',', nPos ); |
| if( STRING_NOTFOUND==nEnd ) |
| { |
| sal_Int32 nTmp = aValue.Copy(nPos).ToInt32(); |
| rLongs.Insert( nTmp >= 0 ? (sal_uInt32)nTmp : 0, |
| rLongs.Count() ); |
| nPos = aValue.Len(); |
| } |
| else |
| { |
| sal_Int32 nTmp = |
| aValue.Copy(nPos,nEnd-nPos).ToInt32(); |
| rLongs.Insert( nTmp >= 0 ? (sal_uInt32)nTmp : 0, |
| rLongs.Count() ); |
| nPos = nEnd+1; |
| } |
| } |
| } |
| } |
| } |
| |
| void HTMLOption::GetColor( Color& rColor ) const |
| { |
| DBG_ASSERT( (nToken>=HTML_OPTION_COLOR_START && nToken<HTML_OPTION_COLOR_END) || nToken==HTML_O_SIZE, |
| "GetColor: Option spezifiziert keine Farbe" ); |
| |
| String aTmp( aValue ); |
| aTmp.ToUpperAscii(); |
| sal_uLong nColor = ULONG_MAX; |
| if( '#'!=aTmp.GetChar( 0 ) ) |
| nColor = GetHTMLColor( aTmp ); |
| |
| if( ULONG_MAX == nColor ) |
| { |
| nColor = 0; |
| xub_StrLen nPos = 0; |
| for( sal_uInt32 i=0; i<6; i++ ) |
| { |
| // MIB 26.06.97: Wie auch immer Netscape Farbwerte ermittelt, |
| // maximal drei Zeichen, die kleiner als '0' sind werden |
| // ignoriert. Bug #40901# stimmt damit. Mal schauen, was sich |
| // irgendwelche HTML-Autoren noch so einfallen lassen... |
| register sal_Unicode c = nPos<aTmp.Len() ? aTmp.GetChar( nPos++ ) |
| : '0'; |
| if( c < '0' ) |
| { |
| c = nPos<aTmp.Len() ? aTmp.GetChar(nPos++) : '0'; |
| if( c < '0' ) |
| c = nPos<aTmp.Len() ? aTmp.GetChar(nPos++) : '0'; |
| } |
| nColor *= 16; |
| if( c >= '0' && c <= '9' ) |
| nColor += (c - 48); |
| else if( c >= 'A' && c <= 'F' ) |
| nColor += (c - 55); |
| } |
| } |
| |
| rColor.SetRed( (sal_uInt8)((nColor & 0x00ff0000) >> 16) ); |
| rColor.SetGreen( (sal_uInt8)((nColor & 0x0000ff00) >> 8)); |
| rColor.SetBlue( (sal_uInt8)(nColor & 0x000000ff) ); |
| } |
| |
| HTMLInputType HTMLOption::GetInputType() const |
| { |
| DBG_ASSERT( nToken==HTML_O_TYPE, "GetInputType: Option nicht TYPE" ); |
| return (HTMLInputType)GetEnum( aInputTypeOptEnums, HTML_IT_TEXT ); |
| } |
| |
| HTMLTableFrame HTMLOption::GetTableFrame() const |
| { |
| DBG_ASSERT( nToken==HTML_O_FRAME, "GetTableFrame: Option nicht FRAME" ); |
| return (HTMLTableFrame)GetEnum( aTableFrameOptEnums, HTML_TF_VOID ); |
| } |
| |
| HTMLTableRules HTMLOption::GetTableRules() const |
| { |
| DBG_ASSERT( nToken==HTML_O_RULES, "GetTableRules: Option nicht RULES" ); |
| return (HTMLTableRules)GetEnum( aTableRulesOptEnums, HTML_TR_NONE ); |
| } |
| |
| /* */ |
| |
| HTMLParser::HTMLParser( SvStream& rIn, int bReadNewDoc ) |
| : SvParser( rIn ) |
| { |
| bNewDoc = bReadNewDoc; |
| bReadListing = bReadXMP = bReadPRE = bReadTextArea = |
| bReadScript = bReadStyle = |
| bEndTokenFound = bIsInBody = bReadNextChar = |
| bReadComment = sal_False; |
| bIsInHeader = sal_True; |
| pOptions = new HTMLOptions; |
| |
| //#i76649, default to UTF-8 for HTML unless we know differently |
| SetSrcEncoding(RTL_TEXTENCODING_UTF8); |
| } |
| |
| HTMLParser::~HTMLParser() |
| { |
| if( pOptions && pOptions->Count() ) |
| pOptions->DeleteAndDestroy( 0, pOptions->Count() ); |
| delete pOptions; |
| } |
| |
| SvParserState __EXPORT HTMLParser::CallParser() |
| { |
| eState = SVPAR_WORKING; |
| nNextCh = GetNextChar(); |
| SaveState( 0 ); |
| |
| nPre_LinePos = 0; |
| bPre_IgnoreNewPara = sal_False; |
| |
| AddRef(); |
| Continue( 0 ); |
| if( SVPAR_PENDING != eState ) |
| ReleaseRef(); // dann brauchen wir den Parser nicht mehr! |
| |
| return eState; |
| } |
| |
| void HTMLParser::Continue( int nToken ) |
| { |
| if( !nToken ) |
| nToken = GetNextToken(); |
| |
| while( IsParserWorking() ) |
| { |
| SaveState( nToken ); |
| nToken = FilterToken( nToken ); |
| |
| if( nToken ) |
| NextToken( nToken ); |
| |
| if( IsParserWorking() ) |
| SaveState( 0 ); // bis hierhin abgearbeitet, |
| // weiter mit neuem Token! |
| nToken = GetNextToken(); |
| } |
| } |
| |
| int HTMLParser::FilterToken( int nToken ) |
| { |
| switch( nToken ) |
| { |
| case sal_Unicode(EOF): |
| nToken = 0; |
| break; // nicht verschicken |
| |
| case HTML_HEAD_OFF: |
| bIsInBody = sal_True; |
| case HTML_HEAD_ON: |
| bIsInHeader = HTML_HEAD_ON == nToken; |
| break; |
| |
| case HTML_BODY_ON: |
| case HTML_FRAMESET_ON: |
| bIsInHeader = sal_False; |
| bIsInBody = HTML_BODY_ON == nToken; |
| break; |
| |
| case HTML_BODY_OFF: |
| bIsInBody = bReadPRE = bReadListing = bReadXMP = sal_False; |
| break; |
| |
| case HTML_HTML_OFF: |
| nToken = 0; |
| bReadPRE = bReadListing = bReadXMP = sal_False; |
| break; // HTML_ON wurde auch nicht verschickt ! |
| |
| case HTML_PREFORMTXT_ON: |
| StartPRE(); |
| break; |
| |
| case HTML_PREFORMTXT_OFF: |
| FinishPRE(); |
| break; |
| |
| case HTML_LISTING_ON: |
| StartListing(); |
| break; |
| |
| case HTML_LISTING_OFF: |
| FinishListing(); |
| break; |
| |
| case HTML_XMP_ON: |
| StartXMP(); |
| break; |
| |
| case HTML_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; |
| } |
| |
| #define HTML_ISDIGIT( c ) (c >= '0' && c <= '9') |
| #define HTML_ISALPHA( c ) ( (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ) |
| #define HTML_ISALNUM( c ) ( HTML_ISALPHA(c) || HTML_ISDIGIT(c) ) |
| #define HTML_ISSPACE( c ) ( ' ' == c || (c >= 0x09 && c <= 0x0d) ) |
| #define HTML_ISPRINTABLE( c ) ( c >= 32 && c != 127) |
| // --> OD 2006-07-26 #138464# |
| #define HTML_ISHEXDIGIT( c ) ( HTML_ISDIGIT(c) || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') ) |
| // <-- |
| |
| int HTMLParser::ScanText( const sal_Unicode cBreak ) |
| { |
| ::rtl::OUStringBuffer sTmpBuffer( MAX_LEN ); |
| int bWeiter = sal_True; |
| int bEqSignFound = sal_False; |
| sal_Unicode cQuote = 0U; |
| |
| while( bWeiter && IsParserWorking() ) |
| { |
| int bNextCh = sal_True; |
| switch( nNextCh ) |
| { |
| case '&': |
| bEqSignFound = sal_False; |
| if( bReadXMP ) |
| sTmpBuffer.append( (sal_Unicode)'&' ); |
| else |
| { |
| sal_uLong nStreamPos = rInput.Tell(); |
| sal_uLong nLinePos = GetLinePos(); |
| |
| sal_Unicode cChar = 0U; |
| if( '#' == (nNextCh = GetNextChar()) ) |
| { |
| nNextCh = GetNextChar(); |
| // --> OD 2006-07-26 #138464# |
| // consider hexadecimal digits |
| const sal_Bool bIsHex( 'x' == nNextCh ); |
| const sal_Bool bIsDecOrHex( bIsHex || HTML_ISDIGIT(nNextCh) ); |
| if ( bIsDecOrHex ) |
| { |
| if ( bIsHex ) |
| { |
| nNextCh = GetNextChar(); |
| while ( HTML_ISHEXDIGIT(nNextCh) ) |
| { |
| cChar = cChar * 16U + |
| ( nNextCh <= '9' |
| ? sal_Unicode( nNextCh - '0' ) |
| : ( nNextCh <= 'F' |
| ? sal_Unicode( nNextCh - 'A' + 10 ) |
| : sal_Unicode( nNextCh - 'a' + 10 ) ) ); |
| nNextCh = GetNextChar(); |
| } |
| } |
| else |
| { |
| do |
| { |
| cChar = cChar * 10U + sal_Unicode( nNextCh - '0'); |
| nNextCh = GetNextChar(); |
| } |
| while( HTML_ISDIGIT(nNextCh) ); |
| } |
| |
| if( RTL_TEXTENCODING_DONTKNOW != eSrcEnc && |
| RTL_TEXTENCODING_UCS2 != eSrcEnc && |
| RTL_TEXTENCODING_UTF8 != eSrcEnc && |
| cChar < 256 ) |
| { |
| sal_Unicode cOrig = cChar; |
| cChar = ByteString::ConvertToUnicode( |
| (sal_Char)cChar, eSrcEnc ); |
| if( 0U == cChar ) |
| { |
| // #73398#: If the character could not be |
| // converted, because a conversion is not |
| // available, do no conversion at all. |
| cChar = cOrig; |
| } |
| } |
| } |
| // <-- |
| else |
| nNextCh = 0U; |
| } |
| else if( HTML_ISALPHA( nNextCh ) ) |
| { |
| ::rtl::OUStringBuffer sEntityBuffer( MAX_ENTITY_LEN ); |
| xub_StrLen nPos = 0L; |
| do |
| { |
| sEntityBuffer.append( nNextCh ); |
| nPos++; |
| nNextCh = GetNextChar(); |
| } |
| while( nPos < MAX_ENTITY_LEN && HTML_ISALNUM( nNextCh ) && |
| !rInput.IsEof() ); |
| |
| if( IsParserWorking() && !rInput.IsEof() ) |
| { |
| String sEntity( sEntityBuffer.getStr(), nPos ); |
| cChar = GetHTMLCharName( sEntity ); |
| |
| // nicht gefunden ( == 0 ), dann Klartext |
| // oder ein Zeichen das als Attribut eingefuegt |
| // wird |
| if( 0U == cChar && ';' != nNextCh ) |
| { |
| DBG_ASSERT( rInput.Tell() - nStreamPos == |
| (sal_uLong)(nPos+1L)*GetCharSize(), |
| "UTF-8 geht hier schief" ); |
| for( xub_StrLen i=nPos-1L; i>1L; i-- ) |
| { |
| nNextCh = sEntityBuffer[i]; |
| sEntityBuffer.setLength( i ); |
| sEntity.Assign( sEntityBuffer.getStr(), i ); |
| cChar = GetHTMLCharName( sEntity ); |
| if( cChar ) |
| { |
| rInput.SeekRel( -(long) |
| ((nPos-i)*GetCharSize()) ); |
| nlLinePos -= sal_uInt32(nPos-i); |
| nPos = i; |
| ClearTxtConvContext(); |
| break; |
| } |
| } |
| } |
| |
| if( !cChar ) // unbekanntes Zeichen? |
| { |
| // dann im Stream zurueck, das '&' als Zeichen |
| // einfuegen und mit dem nachfolgenden Zeichen |
| // wieder aufsetzen |
| sTmpBuffer.append( (sal_Unicode)'&' ); |
| |
| // rInput.SeekRel( -(long)(++nPos*GetCharSize()) ); |
| // nlLinePos -= nPos; |
| DBG_ASSERT( rInput.Tell()-nStreamPos == |
| (sal_uLong)(nPos+1)*GetCharSize(), |
| "Falsche Stream-Position" ); |
| DBG_ASSERT( nlLinePos-nLinePos == |
| (sal_uLong)(nPos+1), |
| "Falsche Zeilen-Position" ); |
| rInput.Seek( nStreamPos ); |
| nlLinePos = nLinePos; |
| ClearTxtConvContext(); |
| break; |
| } |
| |
| // 1 == Non Breaking Space |
| // 2 == SoftHyphen |
| |
| if( cChar < 3U ) |
| { |
| if( '>' == cBreak ) |
| { |
| // Wenn der Inhalt eines Tags gelesen wird, |
| // muessen wir ein Space bzw. - daraus machen |
| switch( cChar ) |
| { |
| case 1U: cChar = ' '; break; |
| case 2U: cChar = '-'; break; |
| default: |
| DBG_ASSERT( cChar==1U, |
| "\0x00 sollte doch schon laengt abgefangen sein!" ); |
| break; |
| } |
| } |
| else |
| { |
| // Wenn kein Tag gescannt wird, enstprechendes |
| // Token zurueckgeben |
| aToken += |
| String( sTmpBuffer.makeStringAndClear() ); |
| if( cChar ) |
| { |
| if( aToken.Len() ) |
| { |
| // mit dem Zeichen wieder aufsetzen |
| nNextCh = '&'; |
| // rInput.SeekRel( -(long)(++nPos*GetCharSize()) ); |
| // nlLinePos -= nPos; |
| DBG_ASSERT( rInput.Tell()-nStreamPos == |
| (sal_uLong)(nPos+1)*GetCharSize(), |
| "Falsche Stream-Position" ); |
| DBG_ASSERT( nlLinePos-nLinePos == |
| (sal_uLong)(nPos+1), |
| "Falsche Zeilen-Position" ); |
| rInput.Seek( nStreamPos ); |
| nlLinePos = nLinePos; |
| ClearTxtConvContext(); |
| return HTML_TEXTTOKEN; |
| } |
| |
| // Hack: _GetNextChar soll nicht das |
| // naechste Zeichen lesen |
| if( ';' != nNextCh ) |
| aToken += ' '; |
| if( 1U == cChar ) |
| return HTML_NONBREAKSPACE; |
| if( 2U == cChar ) |
| return HTML_SOFTHYPH; |
| } |
| aToken += (sal_Unicode)'&'; |
| aToken += |
| String(sEntityBuffer.makeStringAndClear()); |
| break; |
| } |
| } |
| } |
| else |
| nNextCh = 0U; |
| } |
| // MIB 03/02/2000: &{...};-JavaScript-Macros are not |
| // supported any longer. |
| else if( IsParserWorking() ) |
| { |
| sTmpBuffer.append( (sal_Unicode)'&' ); |
| bNextCh = sal_False; |
| break; |
| } |
| |
| bNextCh = (';' == nNextCh); |
| if( cBreak=='>' && (cChar=='\\' || cChar=='\'' || |
| cChar=='\"' || cChar==' ') ) |
| { |
| // ' und " mussen innerhalb von Tags mit einem |
| // gekennzeichnet werden, um sie von ' und " als Klammern |
| // um Optionen zu unterscheiden. Logischerweise muss |
| // deshalb auch ein \ gekeenzeichnet werden. Ausserdem |
| // schuetzen wir ein Space, weil es kein Trennzeichen |
| // zwischen Optionen ist. |
| sTmpBuffer.append( (sal_Unicode)'\\' ); |
| if( MAX_LEN == sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| } |
| if( IsParserWorking() ) |
| { |
| if( cChar ) |
| sTmpBuffer.append( cChar ); |
| } |
| else if( SVPAR_PENDING==eState && '>'!=cBreak ) |
| { |
| // Mit dem '&' Zeichen wieder aufsetzen, der Rest |
| // wird als Texttoken zurueckgegeben. |
| if( aToken.Len() || sTmpBuffer.getLength() ) |
| { |
| // Der bisherige Text wird von _GetNextChar() |
| // zurueckgegeben und beim naechsten Aufruf wird |
| // ein neues Zeichen gelesen. Also muessen wir uns |
| // noch vor das & stellen. |
| nNextCh = 0U; |
| rInput.Seek( nStreamPos-(sal_uInt32)GetCharSize() ); |
| nlLinePos = nLinePos-1; |
| ClearTxtConvContext(); |
| bReadNextChar = sal_True; |
| } |
| bNextCh = sal_False; |
| } |
| } |
| break; |
| case '=': |
| if( '>'==cBreak && !cQuote ) |
| bEqSignFound = sal_True; |
| sTmpBuffer.append( nNextCh ); |
| break; |
| |
| case '\\': |
| if( '>'==cBreak ) |
| { |
| // Innerhalb von Tags kennzeichnen |
| sTmpBuffer.append( (sal_Unicode)'\\' ); |
| if( MAX_LEN == sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| } |
| sTmpBuffer.append( (sal_Unicode)'\\' ); |
| break; |
| |
| case '\"': |
| case '\'': |
| if( '>'==cBreak ) |
| { |
| if( bEqSignFound ) |
| cQuote = nNextCh; |
| else if( cQuote && (cQuote==nNextCh ) ) |
| cQuote = 0U; |
| } |
| sTmpBuffer.append( nNextCh ); |
| bEqSignFound = sal_False; |
| break; |
| |
| case sal_Unicode(EOF): |
| if( rInput.IsEof() ) |
| { |
| // MIB 20.11.98: Das macht hier keinen Sinn, oder doch: Zumindest wird |
| // abcä<EOF> nicht angezeigt, also lassen wir das in Zukunft. |
| // if( '>' != cBreak ) |
| // eState = SVPAR_ACCEPTED; |
| bWeiter = sal_False; |
| } |
| else |
| { |
| sTmpBuffer.append( nNextCh ); |
| } |
| break; |
| |
| case '<': |
| bEqSignFound = sal_False; |
| if( '>'==cBreak ) |
| sTmpBuffer.append( nNextCh ); |
| else |
| bWeiter = sal_False; // Abbrechen, String zusammen |
| break; |
| |
| case '\f': |
| if( '>' == cBreak ) |
| { |
| // Beim Scannen von Optionen wie ein Space behandeln |
| sTmpBuffer.append( (sal_Unicode)' ' ); |
| } |
| else |
| { |
| // sonst wird es ein eigenes Token |
| bWeiter = sal_False; |
| } |
| break; |
| |
| case '\r': |
| case '\n': |
| if( '>'==cBreak ) |
| { |
| // #26979# cr/lf in Tag wird in _GetNextToken() behandeln |
| sTmpBuffer.append( nNextCh ); |
| break; |
| } |
| else if( bReadListing || bReadXMP || bReadPRE || bReadTextArea ) |
| { |
| bWeiter = sal_False; |
| break; |
| } |
| // Bug 18984: CR-LF -> Blank |
| // Folge von CR/LF/BLANK/TAB nur in ein Blank wandeln |
| // kein break!! |
| case '\t': |
| if( '\t'==nNextCh && bReadPRE && '>'!=cBreak ) |
| { |
| // In <PRE>: Tabs nach oben durchreichen |
| bWeiter = sal_False; |
| break; |
| } |
| // kein break |
| case '\x0b': |
| if( '\x0b'==nNextCh && (bReadPRE || bReadXMP ||bReadListing) && |
| '>'!=cBreak ) |
| { |
| break; |
| } |
| nNextCh = ' '; |
| // kein break; |
| case ' ': |
| sTmpBuffer.append( nNextCh ); |
| if( '>'!=cBreak && (!bReadListing && !bReadXMP && |
| !bReadPRE && !bReadTextArea) ) |
| { |
| // alle Folgen von Blanks/Tabs/CR/LF zu einem Blank umwandeln |
| do { |
| if( sal_Unicode(EOF) == (nNextCh = GetNextChar()) && |
| rInput.IsEof() ) |
| { |
| if( aToken.Len() || sTmpBuffer.getLength() > 1L ) |
| { |
| // ausser den Blanks wurde noch etwas geselen |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| return HTML_TEXTTOKEN; |
| } |
| else |
| // nur Blanks gelesen: dann darf kein Text |
| // mehr zurueckgegeben werden und _GetNextToken |
| // muss auf EOF laufen |
| return 0; |
| } |
| } while ( ' ' == nNextCh || '\t' == nNextCh || |
| '\r' == nNextCh || '\n' == nNextCh || |
| '\x0b' == nNextCh ); |
| bNextCh = sal_False; |
| } |
| break; |
| |
| default: |
| bEqSignFound = sal_False; |
| if( (nNextCh==cBreak && !cQuote) || |
| (sal_uLong(aToken.Len()) + MAX_LEN) > sal_uLong(STRING_MAXLEN & ~1 )) |
| bWeiter = sal_False; |
| else |
| { |
| do { |
| // alle anderen Zeichen kommen in den Text |
| sTmpBuffer.append( nNextCh ); |
| if( MAX_LEN == sTmpBuffer.getLength() ) |
| { |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| if( (sal_uLong(aToken.Len()) + MAX_LEN) > |
| sal_uLong(STRING_MAXLEN & ~1 ) ) |
| { |
| nNextCh = GetNextChar(); |
| return HTML_TEXTTOKEN; |
| } |
| } |
| if( ( sal_Unicode(EOF) == (nNextCh = GetNextChar()) && |
| rInput.IsEof() ) || |
| !IsParserWorking() ) |
| { |
| if( sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| return HTML_TEXTTOKEN; |
| } |
| } while( HTML_ISALPHA( nNextCh ) || HTML_ISDIGIT( nNextCh ) ); |
| bNextCh = sal_False; |
| } |
| } |
| |
| if( MAX_LEN == sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| |
| if( bWeiter && bNextCh ) |
| nNextCh = GetNextChar(); |
| } |
| |
| if( sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| |
| return HTML_TEXTTOKEN; |
| } |
| |
| int HTMLParser::_GetNextRawToken() |
| { |
| ::rtl::OUStringBuffer sTmpBuffer( MAX_LEN ); |
| |
| if( bEndTokenFound ) |
| { |
| // beim letzten Aufruf haben wir das End-Token bereits gefunden, |
| // deshalb muessen wir es nicht noch einmal suchen |
| bReadScript = sal_False; |
| bReadStyle = sal_False; |
| aEndToken.Erase(); |
| bEndTokenFound = sal_False; |
| |
| return 0; |
| } |
| |
| // per default geben wir HTML_RAWDATA zurueck |
| int bWeiter = sal_True; |
| int nToken = HTML_RAWDATA; |
| SaveState( 0 ); |
| while( bWeiter && IsParserWorking() ) |
| { |
| int bNextCh = sal_True; |
| switch( nNextCh ) |
| { |
| case '<': |
| { |
| // Vielleicht haben wir das Ende erreicht |
| |
| // das bisher gelesene erstmal retten |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| |
| // und die Position im Stream merken |
| sal_uLong nStreamPos = rInput.Tell(); |
| sal_uLong nLineNr = GetLineNr(); |
| sal_uLong nLinePos = GetLinePos(); |
| |
| // Start eines End-Token? |
| int bOffState = sal_False; |
| if( '/' == (nNextCh = GetNextChar()) ) |
| { |
| bOffState = sal_True; |
| nNextCh = GetNextChar(); |
| } |
| else if( '!' == nNextCh ) |
| { |
| sTmpBuffer.append( nNextCh ); |
| nNextCh = GetNextChar(); |
| } |
| |
| // jetzt die Buchstaben danach lesen |
| while( (HTML_ISALPHA(nNextCh) || '-'==nNextCh) && |
| IsParserWorking() && sTmpBuffer.getLength() < MAX_LEN ) |
| { |
| sTmpBuffer.append( nNextCh ); |
| nNextCh = GetNextChar(); |
| } |
| |
| String aTok( sTmpBuffer.getStr(), |
| sal::static_int_cast< xub_StrLen >( |
| sTmpBuffer.getLength()) ); |
| aTok.ToUpperAscii(); |
| sal_Bool bDone = sal_False; |
| if( bReadScript || aEndToken.Len() ) |
| { |
| if( !bReadComment ) |
| { |
| if( aTok.CompareToAscii( OOO_STRING_SVTOOLS_HTML_comment, 3 ) |
| == COMPARE_EQUAL ) |
| { |
| bReadComment = sal_True; |
| } |
| else |
| { |
| // ein Script muss mit "</SCRIPT>" aufhoehren, wobei |
| // wir es mit dem ">" aus sicherheitsgruenden |
| // erstmal nicht so genau nehmen |
| bDone = bOffState && // '>'==nNextCh && |
| COMPARE_EQUAL == ( bReadScript |
| ? aTok.CompareToAscii(OOO_STRING_SVTOOLS_HTML_script) |
| : aTok.CompareTo(aEndToken) ); |
| } |
| } |
| if( bReadComment && '>'==nNextCh && aTok.Len() >= 2 && |
| aTok.Copy( aTok.Len()-2 ).EqualsAscii( "--" ) ) |
| { |
| // hier ist ein Kommentar der Art <!-----> zuende |
| bReadComment = sal_False; |
| } |
| } |
| else |
| { |
| // ein Style-Sheet kann mit </STYLE>, </HEAD> oder |
| // <BODY> aughoehren |
| if( bOffState ) |
| bDone = aTok.CompareToAscii(OOO_STRING_SVTOOLS_HTML_style) |
| == COMPARE_EQUAL || |
| aTok.CompareToAscii(OOO_STRING_SVTOOLS_HTML_head) |
| == COMPARE_EQUAL; |
| else |
| bDone = |
| aTok.CompareToAscii(OOO_STRING_SVTOOLS_HTML_body) == COMPARE_EQUAL; |
| } |
| |
| if( bDone ) |
| { |
| // das war's, jetzt muessen wir gegebenenfalls den |
| // bisher gelesenen String zurueckgeben und dnach normal |
| // weitermachen |
| |
| bWeiter = sal_False; |
| |
| // nToken==0 heisst, dass _GetNextToken gleich weiterliest |
| if( !aToken.Len() && (bReadStyle || bReadScript) ) |
| { |
| // wir koennen sofort die Umgebung beeden und |
| // das End-Token parsen |
| bReadScript = sal_False; |
| bReadStyle = sal_False; |
| aEndToken.Erase(); |
| nToken = 0; |
| } |
| else |
| { |
| // wir muessen bReadScript/bReadStyle noch am |
| // Leben lassen und koennen erst beim naechsten |
| // mal das End-Token Parsen |
| bEndTokenFound = sal_True; |
| } |
| |
| // jetzt fahren wir im Stream auf das '<' zurueck |
| rInput.Seek( nStreamPos ); |
| SetLineNr( nLineNr ); |
| SetLinePos( nLinePos ); |
| ClearTxtConvContext(); |
| nNextCh = '<'; |
| |
| // den String wollen wir nicht an das Token haengen |
| sTmpBuffer.setLength( 0L ); |
| } |
| else |
| { |
| // "</" merken, alles andere steht noch im buffer |
| aToken += (sal_Unicode)'<'; |
| if( bOffState ) |
| aToken += (sal_Unicode)'/'; |
| |
| bNextCh = sal_False; |
| } |
| } |
| break; |
| case '-': |
| sTmpBuffer.append( nNextCh ); |
| if( bReadComment ) |
| { |
| sal_Bool bTwoMinus = sal_False; |
| nNextCh = GetNextChar(); |
| while( '-' == nNextCh && IsParserWorking() ) |
| { |
| bTwoMinus = sal_True; |
| |
| if( MAX_LEN == sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| sTmpBuffer.append( nNextCh ); |
| nNextCh = GetNextChar(); |
| } |
| |
| if( '>' == nNextCh && IsParserWorking() && bTwoMinus ) |
| bReadComment = sal_False; |
| |
| bNextCh = sal_False; |
| } |
| break; |
| |
| case '\r': |
| // \r\n? beendet das aktuelle Text-Token (auch wenn es leer ist) |
| nNextCh = GetNextChar(); |
| if( nNextCh=='\n' ) |
| nNextCh = GetNextChar(); |
| bWeiter = sal_False; |
| break; |
| case '\n': |
| // \n beendet das aktuelle Text-Token (auch wenn es leer ist) |
| nNextCh = GetNextChar(); |
| bWeiter = sal_False; |
| break; |
| case sal_Unicode(EOF): |
| // eof beendet das aktuelle Text-Token und tut so, als ob |
| // ein End-Token gelesen wurde |
| if( rInput.IsEof() ) |
| { |
| bWeiter = sal_False; |
| if( aToken.Len() || sTmpBuffer.getLength() ) |
| { |
| bEndTokenFound = sal_True; |
| } |
| else |
| { |
| bReadScript = sal_False; |
| bReadStyle = sal_False; |
| aEndToken.Erase(); |
| nToken = 0; |
| } |
| break; |
| } |
| // kein break |
| default: |
| // alle anderen Zeichen landen im Buffer |
| sTmpBuffer.append( nNextCh ); |
| break; |
| } |
| |
| if( (!bWeiter && sTmpBuffer.getLength() > 0L) || |
| MAX_LEN == sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| |
| if( bWeiter && bNextCh ) |
| nNextCh = GetNextChar(); |
| } |
| |
| if( IsParserWorking() ) |
| SaveState( 0 ); |
| else |
| nToken = 0; |
| |
| return nToken; |
| } |
| |
| // scanne das naechste Token, |
| int __EXPORT HTMLParser::_GetNextToken() |
| { |
| int nRet = 0; |
| sSaveToken.Erase(); |
| |
| // die Optionen loeschen |
| if( pOptions->Count() ) |
| pOptions->DeleteAndDestroy( 0, pOptions->Count() ); |
| |
| if( !IsParserWorking() ) // wenn schon Fehler, dann nicht weiter! |
| return 0; |
| |
| sal_Bool bReadNextCharSave = bReadNextChar; |
| if( bReadNextChar ) |
| { |
| DBG_ASSERT( !bEndTokenFound, |
| "</SCRIPT> gelesen und trotzdem noch ein Zeichen lesen?" ); |
| nNextCh = GetNextChar(); |
| if( !IsParserWorking() ) // wenn schon Fehler, dann nicht weiter! |
| return 0; |
| bReadNextChar = sal_False; |
| } |
| |
| if( bReadScript || bReadStyle || aEndToken.Len() ) |
| { |
| nRet = _GetNextRawToken(); |
| if( nRet || !IsParserWorking() ) |
| return nRet; |
| } |
| |
| do { |
| int bNextCh = sal_True; |
| switch( nNextCh ) |
| { |
| case '<': |
| { |
| sal_uLong nStreamPos = rInput.Tell(); |
| sal_uLong nLineNr = GetLineNr(); |
| sal_uLong nLinePos = GetLinePos(); |
| |
| int bOffState = sal_False; |
| if( '/' == (nNextCh = GetNextChar()) ) |
| { |
| bOffState = sal_True; |
| nNextCh = GetNextChar(); |
| } |
| if( HTML_ISALPHA( nNextCh ) || '!'==nNextCh ) // fix #26984# |
| { |
| ::rtl::OUStringBuffer sTmpBuffer; |
| do { |
| sTmpBuffer.append( nNextCh ); |
| if( MAX_LEN == sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| nNextCh = GetNextChar(); |
| } while( '>' != nNextCh && !HTML_ISSPACE( nNextCh ) && |
| IsParserWorking() && !rInput.IsEof() ); |
| |
| if( sTmpBuffer.getLength() ) |
| aToken += String(sTmpBuffer.makeStringAndClear()); |
| |
| // Blanks ueberlesen |
| while( HTML_ISSPACE( nNextCh ) && IsParserWorking() ) |
| nNextCh = GetNextChar(); |
| |
| if( !IsParserWorking() ) |
| { |
| if( SVPAR_PENDING == eState ) |
| bReadNextChar = bReadNextCharSave; |
| break; |
| } |
| |
| // suche das Token in der Tabelle: |
| sSaveToken = aToken; |
| aToken.ToUpperAscii(); |
| if( 0 == (nRet = GetHTMLToken( aToken )) ) |
| // Unknown Control |
| nRet = HTML_UNKNOWNCONTROL_ON; |
| |
| // Wenn es ein Token zum ausschalten ist ... |
| if( bOffState ) |
| { |
| if( HTML_TOKEN_ONOFF & nRet ) |
| { |
| // und es ein Off-Token gibt, das daraus machen |
| ++nRet; |
| } |
| else if( HTML_LINEBREAK!=nRet ) |
| { |
| // und es kein Off-Token gibt, ein unbekanntes |
| // Token daraus machen (ausser </BR>, das wird |
| // wie <BR> behandelt |
| nRet = HTML_UNKNOWNCONTROL_OFF; |
| } |
| } |
| |
| if( nRet == HTML_COMMENT ) |
| { |
| // fix: sSaveToken wegen Gross-/Kleinschreibung |
| // als Anfang des Kommentars benutzen und ein |
| // Space anhaengen. |
| aToken = sSaveToken; |
| if( '>'!=nNextCh ) |
| aToken += (sal_Unicode)' '; |
| sal_uLong nCStreamPos = 0; |
| sal_uLong nCLineNr = 0; |
| sal_uLong nCLinePos = 0; |
| xub_StrLen nCStrLen = 0; |
| |
| sal_Bool bDone = sal_False; |
| // bis zum schliessenden --> lesen. wenn keins gefunden |
| // wurde beim der ersten > wieder aufsetzen |
| while( !bDone && !rInput.IsEof() && IsParserWorking() ) |
| { |
| if( '>'==nNextCh ) |
| { |
| if( !nCStreamPos ) |
| { |
| nCStreamPos = rInput.Tell(); |
| nCStrLen = aToken.Len(); |
| nCLineNr = GetLineNr(); |
| nCLinePos = GetLinePos(); |
| } |
| bDone = aToken.Len() >= 2 && |
| aToken.Copy(aToken.Len()-2,2). |
| EqualsAscii( "--" ); |
| if( !bDone ) |
| aToken += nNextCh; |
| } |
| else |
| aToken += nNextCh; |
| if( !bDone ) |
| nNextCh = GetNextChar(); |
| } |
| if( !bDone && IsParserWorking() && nCStreamPos ) |
| { |
| rInput.Seek( nCStreamPos ); |
| SetLineNr( nCLineNr ); |
| SetLinePos( nCLinePos ); |
| ClearTxtConvContext(); |
| aToken.Erase( nCStrLen ); |
| nNextCh = '>'; |
| } |
| } |
| else |
| { |
| // den TokenString koennen wir jetzt verwerfen |
| aToken.Erase(); |
| } |
| |
| // dann lesen wir mal alles bis zur schliessenden '>' |
| if( '>' != nNextCh && IsParserWorking() ) |
| { |
| ScanText( '>' ); |
| if( sal_Unicode(EOF) == nNextCh && rInput.IsEof() ) |
| { |
| // zurueck hinter die < gehen und dort neu |
| // aufsetzen, das < als Text zurueckgeben |
| rInput.Seek( nStreamPos ); |
| SetLineNr( nLineNr ); |
| SetLinePos( nLinePos ); |
| ClearTxtConvContext(); |
| |
| aToken = '<'; |
| nRet = HTML_TEXTTOKEN; |
| nNextCh = GetNextChar(); |
| bNextCh = sal_False; |
| break; |
| } |
| } |
| if( SVPAR_PENDING == eState ) |
| bReadNextChar = bReadNextCharSave; |
| } |
| else |
| { |
| if( bOffState ) |
| { |
| // einfach alles wegschmeissen |
| ScanText( '>' ); |
| if( sal_Unicode(EOF) == nNextCh && rInput.IsEof() ) |
| { |
| // zurueck hinter die < gehen und dort neu |
| // aufsetzen, das < als Text zurueckgeben |
| rInput.Seek( nStreamPos ); |
| SetLineNr( nLineNr ); |
| SetLinePos( nLinePos ); |
| ClearTxtConvContext(); |
| |
| aToken = '<'; |
| nRet = HTML_TEXTTOKEN; |
| nNextCh = GetNextChar(); |
| bNextCh = sal_False; |
| break; |
| } |
| if( SVPAR_PENDING == eState ) |
| bReadNextChar = bReadNextCharSave; |
| aToken.Erase(); |
| } |
| else if( '%' == nNextCh ) |
| { |
| nRet = HTML_UNKNOWNCONTROL_ON; |
| |
| sal_uLong nCStreamPos = rInput.Tell(); |
| sal_uLong nCLineNr = GetLineNr(), nCLinePos = GetLinePos(); |
| |
| sal_Bool bDone = sal_False; |
| // bis zum schliessenden %> lesen. wenn keins gefunden |
| // wurde beim der ersten > wieder aufsetzen |
| while( !bDone && !rInput.IsEof() && IsParserWorking() ) |
| { |
| bDone = '>'==nNextCh && aToken.Len() >= 1 && |
| '%' == aToken.GetChar( aToken.Len()-1 ); |
| if( !bDone ) |
| { |
| aToken += nNextCh; |
| nNextCh = GetNextChar(); |
| } |
| } |
| if( !bDone && IsParserWorking() ) |
| { |
| rInput.Seek( nCStreamPos ); |
| SetLineNr( nCLineNr ); |
| SetLinePos( nCLinePos ); |
| ClearTxtConvContext(); |
| aToken.AssignAscii( "<%", 2 ); |
| nRet = HTML_TEXTTOKEN; |
| break; |
| } |
| if( IsParserWorking() ) |
| { |
| sSaveToken = aToken; |
| aToken.Erase(); |
| } |
| } |
| else |
| { |
| aToken = '<'; |
| nRet = HTML_TEXTTOKEN; |
| bNextCh = sal_False; |
| break; |
| } |
| } |
| |
| if( IsParserWorking() ) |
| { |
| bNextCh = '>' == nNextCh; |
| switch( nRet ) |
| { |
| case HTML_TEXTAREA_ON: |
| bReadTextArea = sal_True; |
| break; |
| case HTML_TEXTAREA_OFF: |
| bReadTextArea = sal_False; |
| break; |
| case HTML_SCRIPT_ON: |
| if( !bReadTextArea ) |
| bReadScript = sal_True; |
| break; |
| case HTML_SCRIPT_OFF: |
| if( !bReadTextArea ) |
| { |
| bReadScript = sal_False; |
| // JavaScript kann den Stream veraendern |
| // also muss das letzte Zeichen nochmals |
| // gelesen werden |
| bReadNextChar = sal_True; |
| bNextCh = sal_False; |
| } |
| break; |
| |
| case HTML_STYLE_ON: |
| bReadStyle = sal_True; |
| break; |
| case HTML_STYLE_OFF: |
| bReadStyle = sal_False; |
| break; |
| } |
| |
| } |
| } |
| break; |
| |
| case sal_Unicode(EOF): |
| if( rInput.IsEof() ) |
| { |
| eState = SVPAR_ACCEPTED; |
| nRet = nNextCh; |
| } |
| else |
| { |
| // normalen Text lesen |
| goto scan_text; |
| } |
| break; |
| |
| case '\f': |
| // Form-Feeds werden jetzt extra nach oben gereicht |
| nRet = HTML_LINEFEEDCHAR; // !!! eigentlich FORMFEEDCHAR |
| break; |
| |
| case '\n': |
| case '\r': |
| if( bReadListing || bReadXMP || bReadPRE || bReadTextArea ) |
| { |
| sal_Unicode c = GetNextChar(); |
| if( ( '\n' != nNextCh || '\r' != c ) && |
| ( '\r' != nNextCh || '\n' != c ) ) |
| { |
| bNextCh = sal_False; |
| nNextCh = c; |
| } |
| nRet = HTML_NEWPARA; |
| break; |
| } |
| // kein break ! |
| case '\t': |
| if( bReadPRE ) |
| { |
| nRet = HTML_TABCHAR; |
| break; |
| } |
| // kein break ! |
| case ' ': |
| // kein break ! |
| default: |
| |
| scan_text: |
| // es folgt "normaler" Text |
| nRet = ScanText(); |
| bNextCh = 0 == aToken.Len(); |
| |
| // der Text sollte noch verarbeitet werden |
| if( !bNextCh && eState == SVPAR_PENDING ) |
| { |
| eState = SVPAR_WORKING; |
| bReadNextChar = sal_True; |
| } |
| |
| break; |
| } |
| |
| if( bNextCh && SVPAR_WORKING == eState ) |
| { |
| nNextCh = GetNextChar(); |
| if( SVPAR_PENDING == eState && nRet && HTML_TEXTTOKEN != nRet ) |
| { |
| bReadNextChar = sal_True; |
| eState = SVPAR_WORKING; |
| } |
| } |
| |
| } while( !nRet && SVPAR_WORKING == eState ); |
| |
| if( SVPAR_PENDING == eState ) |
| nRet = -1; // irgendwas ungueltiges |
| |
| return nRet; |
| } |
| |
| void HTMLParser::UnescapeToken() |
| { |
| xub_StrLen nPos=0; |
| |
| sal_Bool bEscape = sal_False; |
| while( nPos < aToken.Len() ) |
| { |
| sal_Bool bOldEscape = bEscape; |
| bEscape = sal_False; |
| if( '\\'==aToken.GetChar(nPos) && !bOldEscape ) |
| { |
| aToken.Erase( nPos, 1 ); |
| bEscape = sal_True; |
| } |
| else |
| { |
| nPos++; |
| } |
| } |
| } |
| |
| // hole die Optionen |
| const HTMLOptions *HTMLParser::GetOptions( sal_uInt16 *pNoConvertToken ) const |
| { |
| // wenn die Option fuer das aktuelle Token schon einmal |
| // geholt wurden, geben wir sie noch einmal zurueck |
| if( pOptions->Count() ) |
| return pOptions; |
| |
| xub_StrLen nPos = 0; |
| while( nPos < aToken.Len() ) |
| { |
| // ein Zeichen ? Dann faengt hier eine Option an |
| if( HTML_ISALPHA( aToken.GetChar(nPos) ) ) |
| { |
| int nToken; |
| String aValue; |
| xub_StrLen nStt = nPos; |
| sal_Unicode cChar = 0; |
| |
| // Eigentlich sind hier nur ganz bestimmte Zeichen erlaubt. |
| // Netscape achtet aber nur auf "=" und Leerzeichen (siehe |
| // Mozilla: PA_FetchRequestedNameValues in |
| // lipparse/pa_mdl.c |
| // while( nPos < aToken.Len() && |
| // ( '-'==(c=aToken[nPos]) || isalnum(c) || '.'==c || '_'==c) ) |
| while( nPos < aToken.Len() && '=' != (cChar=aToken.GetChar(nPos)) && |
| HTML_ISPRINTABLE(cChar) && !HTML_ISSPACE(cChar) ) |
| nPos++; |
| |
| String sName( aToken.Copy( nStt, nPos-nStt ) ); |
| |
| //JP 23.03.97: die PlugIns wollen die TokenName im "Original" haben |
| // also nur fuers Suchen in UpperCase wandeln |
| String sNameUpperCase( sName ); |
| sNameUpperCase.ToUpperAscii(); |
| |
| nToken = GetHTMLOption( sNameUpperCase ); // der Name ist fertig |
| DBG_ASSERTWARNING( nToken!=HTML_O_UNKNOWN, |
| "GetOption: unbekannte HTML-Option" ); |
| sal_Bool bStripCRLF = (nToken < HTML_OPTION_SCRIPT_START || |
| nToken >= HTML_OPTION_SCRIPT_END) && |
| (!pNoConvertToken || nToken != *pNoConvertToken); |
| |
| while( nPos < aToken.Len() && |
| ( !HTML_ISPRINTABLE( (cChar=aToken.GetChar(nPos)) ) || |
| HTML_ISSPACE(cChar) ) ) |
| nPos++; |
| |
| // hat die Option auch einen Wert? |
| if( nPos!=aToken.Len() && '='==cChar ) |
| { |
| nPos++; |
| |
| while( nPos < aToken.Len() && |
| ( !HTML_ISPRINTABLE( (cChar=aToken.GetChar(nPos)) ) || |
| ' '==cChar || '\t'==cChar || '\r'==cChar || '\n'==cChar ) ) |
| nPos++; |
| |
| if( nPos != aToken.Len() ) |
| { |
| xub_StrLen nLen = 0; |
| nStt = nPos; |
| if( ('"'==cChar) || ('\'')==cChar ) |
| { |
| sal_Unicode cEnd = cChar; |
| nPos++; nStt++; |
| sal_Bool bDone = sal_False; |
| sal_Bool bEscape = sal_False; |
| while( nPos < aToken.Len() && !bDone ) |
| { |
| sal_Bool bOldEscape = bEscape; |
| bEscape = sal_False; |
| cChar = aToken.GetChar(nPos); |
| switch( cChar ) |
| { |
| case '\r': |
| case '\n': |
| if( bStripCRLF ) |
| ((String &)aToken).Erase( nPos, 1 ); |
| else |
| nPos++, nLen++; |
| break; |
| case '\\': |
| if( bOldEscape ) |
| { |
| nPos++, nLen++; |
| } |
| else |
| { |
| ((String &)aToken).Erase( nPos, 1 ); |
| bEscape = sal_True; |
| } |
| break; |
| case '"': |
| case '\'': |
| bDone = !bOldEscape && cChar==cEnd; |
| if( !bDone ) |
| nPos++, nLen++; |
| break; |
| default: |
| nPos++, nLen++; |
| break; |
| } |
| } |
| if( nPos!=aToken.Len() ) |
| nPos++; |
| } |
| else |
| { |
| // hier sind wir etwas laxer als der |
| // Standard und erlauben alles druckbare |
| sal_Bool bEscape = sal_False; |
| sal_Bool bDone = sal_False; |
| while( nPos < aToken.Len() && !bDone ) |
| { |
| sal_Bool bOldEscape = bEscape; |
| bEscape = sal_False; |
| sal_Unicode c = aToken.GetChar(nPos); |
| switch( c ) |
| { |
| case ' ': |
| bDone = !bOldEscape; |
| if( !bDone ) |
| nPos++, nLen++; |
| break; |
| |
| case '\t': |
| case '\r': |
| case '\n': |
| bDone = sal_True; |
| break; |
| |
| case '\\': |
| if( bOldEscape ) |
| { |
| nPos++, nLen++; |
| } |
| else |
| { |
| ((String &)aToken).Erase( nPos, 1 ); |
| bEscape = sal_True; |
| } |
| break; |
| |
| default: |
| if( HTML_ISPRINTABLE( c ) ) |
| nPos++, nLen++; |
| else |
| bDone = sal_True; |
| break; |
| } |
| } |
| } |
| |
| if( nLen ) |
| aValue = aToken.Copy( nStt, nLen ); |
| } |
| } |
| |
| // Wir kennen das Token und koennen es Speichern |
| HTMLOption *pOption = |
| new HTMLOption( |
| sal::static_int_cast< sal_uInt16 >(nToken), sName, aValue ); |
| |
| pOptions->Insert( pOption, pOptions->Count() ); |
| |
| } |
| else |
| // white space un unerwartete Zeichen ignorieren wie |
| nPos++; |
| } |
| |
| return pOptions; |
| } |
| |
| int HTMLParser::FilterPRE( int nToken ) |
| { |
| switch( nToken ) |
| { |
| #ifdef HTML_BEHAVIOUR |
| // diese werden laut Definition zu LFs |
| case HTML_PARABREAK_ON: |
| case HTML_LINEBREAK: |
| nToken = HTML_NEWPARA; |
| #else |
| // in Netscape zeigen sie aber nur in nicht-leeren Absaetzen Wirkung |
| case HTML_PARABREAK_ON: |
| nToken = HTML_LINEBREAK; |
| case HTML_LINEBREAK: |
| #endif |
| case HTML_NEWPARA: |
| nPre_LinePos = 0; |
| if( bPre_IgnoreNewPara ) |
| nToken = 0; |
| break; |
| |
| case HTML_TABCHAR: |
| { |
| xub_StrLen nSpaces = sal::static_int_cast< xub_StrLen >( |
| 8 - (nPre_LinePos % 8)); |
| DBG_ASSERT( !aToken.Len(), "Wieso ist das Token nicht leer?" ); |
| aToken.Expand( nSpaces, ' ' ); |
| nPre_LinePos += nSpaces; |
| nToken = HTML_TEXTTOKEN; |
| } |
| break; |
| // diese bleiben erhalten |
| case HTML_TEXTTOKEN: |
| nPre_LinePos += aToken.Len(); |
| break; |
| |
| case HTML_SELECT_ON: |
| case HTML_SELECT_OFF: |
| case HTML_BODY_ON: |
| case HTML_FORM_ON: |
| case HTML_FORM_OFF: |
| case HTML_INPUT: |
| case HTML_OPTION: |
| case HTML_TEXTAREA_ON: |
| case HTML_TEXTAREA_OFF: |
| |
| case HTML_IMAGE: |
| case HTML_APPLET_ON: |
| case HTML_APPLET_OFF: |
| case HTML_PARAM: |
| case HTML_EMBED: |
| |
| case HTML_HEAD1_ON: |
| case HTML_HEAD1_OFF: |
| case HTML_HEAD2_ON: |
| case HTML_HEAD2_OFF: |
| case HTML_HEAD3_ON: |
| case HTML_HEAD3_OFF: |
| case HTML_HEAD4_ON: |
| case HTML_HEAD4_OFF: |
| case HTML_HEAD5_ON: |
| case HTML_HEAD5_OFF: |
| case HTML_HEAD6_ON: |
| case HTML_HEAD6_OFF: |
| case HTML_BLOCKQUOTE_ON: |
| case HTML_BLOCKQUOTE_OFF: |
| case HTML_ADDRESS_ON: |
| case HTML_ADDRESS_OFF: |
| case HTML_HORZRULE: |
| |
| case HTML_CENTER_ON: |
| case HTML_CENTER_OFF: |
| case HTML_DIVISION_ON: |
| case HTML_DIVISION_OFF: |
| |
| case HTML_SCRIPT_ON: |
| case HTML_SCRIPT_OFF: |
| case HTML_RAWDATA: |
| |
| case HTML_TABLE_ON: |
| case HTML_TABLE_OFF: |
| case HTML_CAPTION_ON: |
| case HTML_CAPTION_OFF: |
| case HTML_COLGROUP_ON: |
| case HTML_COLGROUP_OFF: |
| case HTML_COL_ON: |
| case HTML_COL_OFF: |
| case HTML_THEAD_ON: |
| case HTML_THEAD_OFF: |
| case HTML_TFOOT_ON: |
| case HTML_TFOOT_OFF: |
| case HTML_TBODY_ON: |
| case HTML_TBODY_OFF: |
| case HTML_TABLEROW_ON: |
| case HTML_TABLEROW_OFF: |
| case HTML_TABLEDATA_ON: |
| case HTML_TABLEDATA_OFF: |
| case HTML_TABLEHEADER_ON: |
| case HTML_TABLEHEADER_OFF: |
| |
| case HTML_ANCHOR_ON: |
| case HTML_ANCHOR_OFF: |
| case HTML_BOLD_ON: |
| case HTML_BOLD_OFF: |
| case HTML_ITALIC_ON: |
| case HTML_ITALIC_OFF: |
| case HTML_STRIKE_ON: |
| case HTML_STRIKE_OFF: |
| case HTML_STRIKETHROUGH_ON: |
| case HTML_STRIKETHROUGH_OFF: |
| case HTML_UNDERLINE_ON: |
| case HTML_UNDERLINE_OFF: |
| case HTML_BASEFONT_ON: |
| case HTML_BASEFONT_OFF: |
| case HTML_FONT_ON: |
| case HTML_FONT_OFF: |
| case HTML_BLINK_ON: |
| case HTML_BLINK_OFF: |
| case HTML_SPAN_ON: |
| case HTML_SPAN_OFF: |
| case HTML_SUBSCRIPT_ON: |
| case HTML_SUBSCRIPT_OFF: |
| case HTML_SUPERSCRIPT_ON: |
| case HTML_SUPERSCRIPT_OFF: |
| case HTML_BIGPRINT_ON: |
| case HTML_BIGPRINT_OFF: |
| case HTML_SMALLPRINT_OFF: |
| case HTML_SMALLPRINT_ON: |
| |
| case HTML_EMPHASIS_ON: |
| case HTML_EMPHASIS_OFF: |
| case HTML_CITIATION_ON: |
| case HTML_CITIATION_OFF: |
| case HTML_STRONG_ON: |
| case HTML_STRONG_OFF: |
| case HTML_CODE_ON: |
| case HTML_CODE_OFF: |
| case HTML_SAMPLE_ON: |
| case HTML_SAMPLE_OFF: |
| case HTML_KEYBOARD_ON: |
| case HTML_KEYBOARD_OFF: |
| case HTML_VARIABLE_ON: |
| case HTML_VARIABLE_OFF: |
| case HTML_DEFINSTANCE_ON: |
| case HTML_DEFINSTANCE_OFF: |
| case HTML_SHORTQUOTE_ON: |
| case HTML_SHORTQUOTE_OFF: |
| case HTML_LANGUAGE_ON: |
| case HTML_LANGUAGE_OFF: |
| case HTML_AUTHOR_ON: |
| case HTML_AUTHOR_OFF: |
| case HTML_PERSON_ON: |
| case HTML_PERSON_OFF: |
| case HTML_ACRONYM_ON: |
| case HTML_ACRONYM_OFF: |
| case HTML_ABBREVIATION_ON: |
| case HTML_ABBREVIATION_OFF: |
| case HTML_INSERTEDTEXT_ON: |
| case HTML_INSERTEDTEXT_OFF: |
| case HTML_DELETEDTEXT_ON: |
| case HTML_DELETEDTEXT_OFF: |
| case HTML_TELETYPE_ON: |
| case HTML_TELETYPE_OFF: |
| |
| break; |
| |
| // der Rest wird als unbekanntes Token behandelt |
| default: |
| if( nToken ) |
| { |
| nToken = |
| ( ((HTML_TOKEN_ONOFF & nToken) && (1 & nToken)) |
| ? HTML_UNKNOWNCONTROL_OFF |
| : HTML_UNKNOWNCONTROL_ON ); |
| } |
| break; |
| } |
| |
| bPre_IgnoreNewPara = sal_False; |
| |
| return nToken; |
| } |
| |
| int HTMLParser::FilterXMP( int nToken ) |
| { |
| switch( nToken ) |
| { |
| case HTML_NEWPARA: |
| if( bPre_IgnoreNewPara ) |
| nToken = 0; |
| case HTML_TEXTTOKEN: |
| case HTML_NONBREAKSPACE: |
| case HTML_SOFTHYPH: |
| break; // bleiben erhalten |
| |
| default: |
| if( nToken ) |
| { |
| if( (HTML_TOKEN_ONOFF & nToken) && (1 & nToken) ) |
| { |
| sSaveToken.Insert( '<', 0 ); |
| sSaveToken.Insert( '/', 1 ); |
| } |
| else |
| sSaveToken.Insert( '<', 0 ); |
| if( aToken.Len() ) |
| { |
| UnescapeToken(); |
| sSaveToken += (sal_Unicode)' '; |
| aToken.Insert( sSaveToken, 0 ); |
| } |
| else |
| aToken = sSaveToken; |
| aToken += (sal_Unicode)'>'; |
| nToken = HTML_TEXTTOKEN; |
| } |
| break; |
| } |
| |
| bPre_IgnoreNewPara = sal_False; |
| |
| return nToken; |
| } |
| |
| int HTMLParser::FilterListing( int nToken ) |
| { |
| switch( nToken ) |
| { |
| case HTML_NEWPARA: |
| if( bPre_IgnoreNewPara ) |
| nToken = 0; |
| case HTML_TEXTTOKEN: |
| case HTML_NONBREAKSPACE: |
| case HTML_SOFTHYPH: |
| break; // bleiben erhalten |
| |
| default: |
| if( nToken ) |
| { |
| nToken = |
| ( ((HTML_TOKEN_ONOFF & nToken) && (1 & nToken)) |
| ? HTML_UNKNOWNCONTROL_OFF |
| : HTML_UNKNOWNCONTROL_ON ); |
| } |
| break; |
| } |
| |
| bPre_IgnoreNewPara = sal_False; |
| |
| return nToken; |
| } |
| |
| FASTBOOL HTMLParser::IsHTMLFormat( const sal_Char* pHeader, |
| sal_Bool bSwitchToUCS2, |
| rtl_TextEncoding eEnc ) |
| { |
| // Einer der folgenden regulaeren Ausdrucke muss sich auf den String |
| // anwenden lassen, damit das Dok ein HTML-Dokument ist. |
| // |
| // ^[^<]*<[^ \t]*[> \t] |
| // ------- |
| // ^<! |
| // |
| // wobei der unterstrichene Teilausdruck einem HTML-Token |
| // ensprechen muss |
| |
| ByteString sCmp; |
| sal_Bool bUCS2B = sal_False; |
| if( bSwitchToUCS2 ) |
| { |
| if( 0xfeU == (sal_uChar)pHeader[0] && |
| 0xffU == (sal_uChar)pHeader[1] ) |
| { |
| eEnc = RTL_TEXTENCODING_UCS2; |
| bUCS2B = sal_True; |
| } |
| else if( 0xffU == (sal_uChar)pHeader[0] && |
| 0xfeU == (sal_uChar)pHeader[1] ) |
| { |
| eEnc = RTL_TEXTENCODING_UCS2; |
| } |
| } |
| if |
| ( |
| RTL_TEXTENCODING_UCS2 == eEnc && |
| ( |
| (0xfe == (sal_uChar)pHeader[0] && 0xff == (sal_uChar)pHeader[1]) || |
| (0xff == (sal_uChar)pHeader[0] && 0xfe == (sal_uChar)pHeader[1]) |
| ) |
| ) |
| { |
| if( 0xfe == (sal_uChar)pHeader[0] ) |
| bUCS2B = sal_True; |
| |
| xub_StrLen nLen; |
| for( nLen = 2; |
| pHeader[nLen] != 0 || pHeader[nLen+1] != 0; |
| nLen+=2 ) |
| ; |
| |
| ::rtl::OStringBuffer sTmp( (nLen - 2)/2 ); |
| for( xub_StrLen nPos = 2; nPos < nLen; nPos += 2 ) |
| { |
| sal_Unicode cUC; |
| if( bUCS2B ) |
| cUC = (sal_Unicode(pHeader[nPos]) << 8) | pHeader[nPos+1]; |
| else |
| cUC = (sal_Unicode(pHeader[nPos+1]) << 8) | pHeader[nPos]; |
| if( 0U == cUC ) |
| break; |
| |
| sTmp.append( cUC < 256U ? (sal_Char)cUC : '.' ); |
| } |
| sCmp = ByteString( sTmp.makeStringAndClear() ); |
| } |
| else |
| { |
| sCmp = (sal_Char *)pHeader; |
| } |
| |
| sCmp.ToUpperAscii(); |
| |
| // Ein HTML-Dokument muss in der ersten Zeile ein '<' besitzen |
| xub_StrLen nStart = sCmp.Search( '<' ); |
| if( STRING_NOTFOUND == nStart ) |
| return sal_False; |
| nStart++; |
| |
| // danach duerfen beliebige andere Zeichen bis zu einem blank oder |
| // '>' kommen |
| sal_Char c; |
| xub_StrLen nPos; |
| for( nPos = nStart; nPos<sCmp.Len(); nPos++ ) |
| { |
| if( '>'==(c=sCmp.GetChar(nPos)) || HTML_ISSPACE(c) ) |
| break; |
| } |
| |
| // wenn das Dokeument hinter dem < aufhoert ist es wohl kein HTML |
| if( nPos==nStart ) |
| return sal_False; |
| |
| // die Zeichenkette nach dem '<' muss ausserdem ein bekanntes |
| // HTML Token sein. Damit die Ausgabe eines DOS-dir-Befehls nicht |
| // als HTML interpretiert wird, wird ein <DIR> jedoch nicht als HTML |
| // interpretiert. |
| String sTest( sCmp.Copy( nStart, nPos-nStart ), RTL_TEXTENCODING_ASCII_US ); |
| int nTok = GetHTMLToken( sTest ); |
| if( 0 != nTok && HTML_DIRLIST_ON != nTok ) |
| return sal_True; |
| |
| // oder es handelt sich um ein "<!" ganz am Anfang der Datei (fix #27092#) |
| if( nStart == 1 && '!' == sCmp.GetChar( 1 ) ) |
| return sal_True; |
| |
| // oder wir finden irgendwo ein <HTML> in den ersten 80 Zeichen |
| nStart = sCmp.Search( OOO_STRING_SVTOOLS_HTML_html ); |
| if( nStart!=STRING_NOTFOUND && |
| nStart>0 && '<'==sCmp.GetChar(nStart-1) && |
| nStart+4 < sCmp.Len() && '>'==sCmp.GetChar(nStart+4) ) |
| return sal_True; |
| |
| // sonst ist es wohl doch eher kein HTML-Dokument |
| return sal_False; |
| } |
| |
| sal_Bool HTMLParser::InternalImgToPrivateURL( String& rURL ) |
| { |
| if( rURL.Len() < 19 || 'i' != rURL.GetChar(0) || |
| rURL.CompareToAscii( OOO_STRING_SVTOOLS_HTML_internal_gopher, 9 ) != COMPARE_EQUAL ) |
| return sal_False; |
| |
| sal_Bool bFound = sal_False; |
| |
| if( rURL.CompareToAscii( OOO_STRING_SVTOOLS_HTML_internal_gopher,16) == COMPARE_EQUAL ) |
| { |
| String aName( rURL.Copy(16) ); |
| switch( aName.GetChar(0) ) |
| { |
| case 'b': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_binary ); |
| break; |
| case 'i': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_image ) || |
| aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_index ); |
| break; |
| case 'm': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_menu ) || |
| aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_movie ); |
| break; |
| case 's': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_sound ); |
| break; |
| case 't': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_telnet ) || |
| aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_text ); |
| break; |
| case 'u': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_GOPHER_unknown ); |
| break; |
| } |
| } |
| else if( rURL.CompareToAscii( OOO_STRING_SVTOOLS_HTML_internal_icon,14) == COMPARE_EQUAL ) |
| { |
| String aName( rURL.Copy(14) ); |
| switch( aName.GetChar(0) ) |
| { |
| case 'b': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_ICON_baddata ); |
| break; |
| case 'd': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_ICON_delayed ); |
| break; |
| case 'e': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_ICON_embed ); |
| break; |
| case 'i': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_ICON_insecure ); |
| break; |
| case 'n': |
| bFound = aName.EqualsAscii( OOO_STRING_SVTOOLS_HTML_INT_ICON_notfound ); |
| break; |
| } |
| } |
| if( bFound ) |
| { |
| String sTmp ( rURL ); |
| rURL.AssignAscii( OOO_STRING_SVTOOLS_HTML_private_image ); |
| rURL.Append( sTmp ); |
| } |
| |
| return bFound; |
| } |
| |
| #ifdef USED |
| void HTMLParser::SaveState( int nToken ) |
| { |
| SvParser::SaveState( nToken ); |
| } |
| |
| void HTMLParser::RestoreState() |
| { |
| SvParser::RestoreState(); |
| } |
| #endif |
| |
| |
| enum eHtmlMetas { |
| HTML_META_NONE = 0, |
| HTML_META_AUTHOR, |
| HTML_META_DESCRIPTION, |
| HTML_META_KEYWORDS, |
| HTML_META_REFRESH, |
| HTML_META_CLASSIFICATION, |
| HTML_META_CREATED, |
| HTML_META_CHANGEDBY, |
| HTML_META_CHANGED, |
| HTML_META_GENERATOR, |
| HTML_META_SDFOOTNOTE, |
| HTML_META_SDENDNOTE, |
| HTML_META_CONTENT_TYPE |
| }; |
| |
| // <META NAME=xxx> |
| static HTMLOptionEnum __READONLY_DATA aHTMLMetaNameTable[] = |
| { |
| { OOO_STRING_SVTOOLS_HTML_META_author, HTML_META_AUTHOR }, |
| { OOO_STRING_SVTOOLS_HTML_META_changed, HTML_META_CHANGED }, |
| { OOO_STRING_SVTOOLS_HTML_META_changedby, HTML_META_CHANGEDBY }, |
| { OOO_STRING_SVTOOLS_HTML_META_classification,HTML_META_CLASSIFICATION}, |
| { OOO_STRING_SVTOOLS_HTML_META_content_type, HTML_META_CONTENT_TYPE }, |
| { OOO_STRING_SVTOOLS_HTML_META_created, HTML_META_CREATED }, |
| { OOO_STRING_SVTOOLS_HTML_META_description, HTML_META_DESCRIPTION }, |
| { OOO_STRING_SVTOOLS_HTML_META_keywords, HTML_META_KEYWORDS }, |
| { OOO_STRING_SVTOOLS_HTML_META_generator, HTML_META_GENERATOR }, |
| { OOO_STRING_SVTOOLS_HTML_META_refresh, HTML_META_REFRESH }, |
| { OOO_STRING_SVTOOLS_HTML_META_sdendnote, HTML_META_SDENDNOTE }, |
| { OOO_STRING_SVTOOLS_HTML_META_sdfootnote, HTML_META_SDFOOTNOTE }, |
| { 0, 0 } |
| }; |
| |
| |
| void HTMLParser::AddMetaUserDefined( ::rtl::OUString const & ) |
| { |
| } |
| |
| bool HTMLParser::ParseMetaOptionsImpl( |
| const uno::Reference<document::XDocumentProperties> & i_xDocProps, |
| SvKeyValueIterator *i_pHTTPHeader, |
| const HTMLOptions *i_pOptions, |
| rtl_TextEncoding& o_rEnc ) |
| { |
| String aName, aContent; |
| sal_uInt16 nAction = HTML_META_NONE; |
| bool bHTTPEquiv = false, bChanged = false; |
| |
| for ( sal_uInt16 i = i_pOptions->Count(); i; ) |
| { |
| const HTMLOption *pOption = (*i_pOptions)[ --i ]; |
| switch ( pOption->GetToken() ) |
| { |
| case HTML_O_NAME: |
| aName = pOption->GetString(); |
| if ( HTML_META_NONE==nAction ) |
| { |
| pOption->GetEnum( nAction, aHTMLMetaNameTable ); |
| } |
| break; |
| case HTML_O_HTTPEQUIV: |
| aName = pOption->GetString(); |
| pOption->GetEnum( nAction, aHTMLMetaNameTable ); |
| bHTTPEquiv = true; |
| break; |
| case HTML_O_CONTENT: |
| aContent = pOption->GetString(); |
| break; |
| } |
| } |
| |
| if ( bHTTPEquiv || HTML_META_DESCRIPTION != nAction ) |
| { |
| // if it is not a Description, remove CRs and LFs from CONTENT |
| aContent.EraseAllChars( _CR ); |
| aContent.EraseAllChars( _LF ); |
| } |
| else |
| { |
| // convert line endings for Description |
| aContent.ConvertLineEnd(); |
| } |
| |
| |
| if ( bHTTPEquiv && i_pHTTPHeader ) |
| { |
| // #57232#: Netscape seems to just ignore a closing ", so we do too |
| if ( aContent.Len() && '"' == aContent.GetChar( aContent.Len()-1 ) ) |
| { |
| aContent.Erase( aContent.Len() - 1 ); |
| } |
| SvKeyValue aKeyValue( aName, aContent ); |
| i_pHTTPHeader->Append( aKeyValue ); |
| } |
| |
| switch ( nAction ) |
| { |
| case HTML_META_AUTHOR: |
| if (i_xDocProps.is()) { |
| i_xDocProps->setAuthor( aContent ); |
| bChanged = true; |
| } |
| break; |
| case HTML_META_DESCRIPTION: |
| if (i_xDocProps.is()) { |
| i_xDocProps->setDescription( aContent ); |
| bChanged = true; |
| } |
| break; |
| case HTML_META_KEYWORDS: |
| if (i_xDocProps.is()) { |
| i_xDocProps->setKeywords( |
| ::comphelper::string::convertCommaSeparated(aContent)); |
| bChanged = true; |
| } |
| break; |
| case HTML_META_CLASSIFICATION: |
| if (i_xDocProps.is()) { |
| i_xDocProps->setSubject( aContent ); |
| bChanged = true; |
| } |
| break; |
| |
| case HTML_META_CHANGEDBY: |
| if (i_xDocProps.is()) { |
| i_xDocProps->setModifiedBy( aContent ); |
| } |
| break; |
| |
| case HTML_META_CREATED: |
| case HTML_META_CHANGED: |
| if ( i_xDocProps.is() && aContent.Len() && |
| aContent.GetTokenCount() == 2 ) |
| { |
| Date aDate( (sal_uLong)aContent.GetToken(0).ToInt32() ); |
| Time aTime( (sal_uLong)aContent.GetToken(1).ToInt32() ); |
| DateTime aDateTime( aDate, aTime ); |
| ::util::DateTime uDT(aDateTime.Get100Sec(), |
| aDateTime.GetSec(), aDateTime.GetMin(), |
| aDateTime.GetHour(), aDateTime.GetDay(), |
| aDateTime.GetMonth(), aDateTime.GetYear()); |
| if ( HTML_META_CREATED==nAction ) |
| i_xDocProps->setCreationDate( uDT ); |
| else |
| i_xDocProps->setModificationDate( uDT ); |
| bChanged = true; |
| } |
| break; |
| |
| case HTML_META_REFRESH: |
| DBG_ASSERT( !bHTTPEquiv || i_pHTTPHeader, |
| "Reload-URL aufgrund unterlassener MUSS-Aenderung verlorengegangen" ); |
| break; |
| |
| case HTML_META_CONTENT_TYPE: |
| if ( aContent.Len() ) |
| { |
| o_rEnc = GetEncodingByMIME( aContent ); |
| } |
| break; |
| |
| case HTML_META_NONE: |
| if ( !bHTTPEquiv ) |
| { |
| if (i_xDocProps.is()) |
| { |
| uno::Reference<beans::XPropertyContainer> xUDProps |
| = i_xDocProps->getUserDefinedProperties(); |
| try { |
| xUDProps->addProperty(aName, |
| beans::PropertyAttribute::REMOVEABLE, |
| uno::makeAny(::rtl::OUString(aContent))); |
| AddMetaUserDefined(aName); |
| bChanged = true; |
| } catch (uno::Exception &) { |
| // ignore |
| } |
| } |
| } |
| break; |
| default: |
| break; |
| } |
| |
| return bChanged; |
| } |
| |
| bool HTMLParser::ParseMetaOptions( |
| const uno::Reference<document::XDocumentProperties> & i_xDocProps, |
| SvKeyValueIterator *i_pHeader ) |
| { |
| sal_uInt16 nContentOption = HTML_O_CONTENT; |
| rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW; |
| |
| bool bRet = ParseMetaOptionsImpl( i_xDocProps, i_pHeader, |
| GetOptions(&nContentOption), |
| eEnc ); |
| |
| // If the encoding is set by a META tag, it may only overwrite the |
| // current encoding if both, the current and the new encoding, are 1-sal_uInt8 |
| // encodings. Everything else cannot lead to reasonable results. |
| if (RTL_TEXTENCODING_DONTKNOW != eEnc && |
| rtl_isOctetTextEncoding( eEnc ) && |
| rtl_isOctetTextEncoding( GetSrcEncoding() ) ) |
| { |
| eEnc = GetExtendedCompatibilityTextEncoding( eEnc ); // #89973# |
| SetSrcEncoding( eEnc ); |
| } |
| |
| return bRet; |
| } |
| |
| rtl_TextEncoding HTMLParser::GetEncodingByMIME( const String& rMime ) |
| { |
| ByteString sType; |
| ByteString sSubType; |
| INetContentTypeParameterList aParameters; |
| ByteString sMime( rMime, RTL_TEXTENCODING_ASCII_US ); |
| if (INetContentTypes::parse(sMime, sType, sSubType, &aParameters)) |
| { |
| const INetContentTypeParameter * pCharset |
| = aParameters.find("charset"); |
| if (pCharset != 0) |
| { |
| ByteString sValue( pCharset->m_sValue, RTL_TEXTENCODING_ASCII_US ); |
| return GetExtendedCompatibilityTextEncoding( |
| rtl_getTextEncodingFromMimeCharset( sValue.GetBuffer() ) ); |
| } |
| } |
| return RTL_TEXTENCODING_DONTKNOW; |
| } |
| |
| rtl_TextEncoding HTMLParser::GetEncodingByHttpHeader( SvKeyValueIterator *pHTTPHeader ) |
| { |
| rtl_TextEncoding eRet = RTL_TEXTENCODING_DONTKNOW; |
| if( pHTTPHeader ) |
| { |
| SvKeyValue aKV; |
| for( sal_Bool bCont = pHTTPHeader->GetFirst( aKV ); bCont; |
| bCont = pHTTPHeader->GetNext( aKV ) ) |
| { |
| if( aKV.GetKey().EqualsIgnoreCaseAscii( OOO_STRING_SVTOOLS_HTML_META_content_type ) ) |
| { |
| if( aKV.GetValue().Len() ) |
| { |
| eRet = HTMLParser::GetEncodingByMIME( aKV.GetValue() ); |
| } |
| } |
| } |
| } |
| return eRet; |
| } |
| |
| sal_Bool HTMLParser::SetEncodingByHTTPHeader( |
| SvKeyValueIterator *pHTTPHeader ) |
| { |
| sal_Bool bRet = sal_False; |
| rtl_TextEncoding eEnc = HTMLParser::GetEncodingByHttpHeader( pHTTPHeader ); |
| if(RTL_TEXTENCODING_DONTKNOW != eEnc) |
| { |
| SetSrcEncoding( eEnc ); |
| bRet = sal_True; |
| } |
| return bRet; |
| } |
| |
| |
