| /************************************************************** |
| * |
| * 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_sc.hxx" |
| |
| //------------------------------------------------------------------------ |
| |
| #include "scitems.hxx" |
| #include <svl/zforlist.hxx> |
| |
| #include "dif.hxx" |
| #include "filter.hxx" |
| #include "fprogressbar.hxx" |
| #include "scerrors.hxx" |
| #include "document.hxx" |
| #include "cell.hxx" |
| #include "patattr.hxx" |
| #include "docpool.hxx" |
| #include "attrib.hxx" |
| #include "ftools.hxx" |
| |
| #include <math.h> |
| |
| const sal_Unicode pKeyTABLE[] = { 'T', 'A', 'B', 'L', 'E', 0 }; |
| const sal_Unicode pKeyVECTORS[] = { 'V', 'E', 'C', 'T', 'O', 'R', 'S', 0 }; |
| const sal_Unicode pKeyTUPLES[] = { 'T', 'U', 'P', 'L', 'E', 'S', 0 }; |
| const sal_Unicode pKeyDATA[] = { 'D', 'A', 'T', 'A', 0 }; |
| const sal_Unicode pKeyBOT[] = { 'B', 'O', 'T', 0 }; |
| const sal_Unicode pKeyEOD[] = { 'E', 'O', 'D', 0 }; |
| const sal_Unicode pKeyERROR[] = { 'E', 'R', 'R', 'O', 'R', 0 }; |
| const sal_Unicode pKeyTRUE[] = { 'T', 'R', 'U', 'E', 0 }; |
| const sal_Unicode pKeyFALSE[] = { 'F', 'A', 'L', 'S', 'E', 0 }; |
| const sal_Unicode pKeyNA[] = { 'N', 'A', 0 }; |
| const sal_Unicode pKeyV[] = { 'V', 0 }; |
| const sal_Unicode pKey1_0[] = { '1', ',', '0', 0 }; |
| |
| |
| FltError ScFormatFilterPluginImpl::ScImportDif( SvStream& rIn, ScDocument* pDoc, const ScAddress& rInsPos, |
| const CharSet eVon, sal_uInt32 nDifOption ) |
| { |
| DifParser aDifParser( rIn, nDifOption, *pDoc, eVon ); |
| |
| const sal_Bool bPlain = aDifParser.IsPlain(); |
| |
| SCTAB nBaseTab = rInsPos.Tab(); |
| |
| TOPIC eTopic = T_UNKNOWN; |
| sal_Bool bSyntErrWarn = sal_False; |
| sal_Bool bOverflowWarn = sal_False; |
| |
| String& rData = aDifParser.aData; |
| sal_Bool bData = sal_False; |
| |
| SCCOL nNumCols = 0; |
| SCROW nNumRows = 0; |
| |
| rIn.Seek( 0 ); |
| |
| ScfStreamProgressBar aPrgrsBar( rIn, pDoc->GetDocumentShell() ); |
| |
| while( eTopic != T_DATA && eTopic != T_END ) |
| { |
| eTopic = aDifParser.GetNextTopic(); |
| |
| aPrgrsBar.Progress(); |
| |
| bData = rData.Len() > 0; |
| |
| switch( eTopic ) |
| { |
| case T_TABLE: |
| { |
| if( aDifParser.nVector != 0 || aDifParser.nVal != 1 ) |
| bSyntErrWarn = sal_True; |
| if( bData ) |
| pDoc->RenameTab( nBaseTab, rData ); |
| } |
| break; |
| case T_VECTORS: |
| { |
| if( aDifParser.nVector != 0 ) |
| bSyntErrWarn = sal_True; |
| if( aDifParser.nVal > MAXCOL + 1 ) |
| nNumCols = SCCOL_MAX; |
| else |
| nNumCols = static_cast<SCCOL>(aDifParser.nVal); |
| } |
| break; |
| case T_TUPLES: |
| { |
| if( aDifParser.nVector != 0 ) |
| bSyntErrWarn = sal_True; |
| if( aDifParser.nVal > MAXROW + 1 ) |
| nNumRows = SCROW_MAX; |
| else |
| nNumRows = static_cast<SCROW>(aDifParser.nVal); |
| } |
| break; |
| case T_DATA: |
| { |
| if( aDifParser.nVector != 0 || aDifParser.nVal != 0 ) |
| bSyntErrWarn = sal_True; |
| } |
| break; |
| case T_LABEL: |
| case T_COMMENT: |
| case T_SIZE: |
| case T_PERIODICITY: |
| case T_MAJORSTART: |
| case T_MINORSTART: |
| case T_TRUELENGTH: |
| case T_UINITS: |
| case T_DISPLAYUNITS: |
| case T_END: |
| case T_UNKNOWN: |
| break; |
| default: |
| DBG_ERRORFILE( "ScImportDif - missing enum" ); |
| } |
| |
| } |
| |
| |
| if( eTopic == T_DATA ) |
| { // Ab hier kommen die Daten |
| SCCOL nBaseCol = rInsPos.Col(); |
| |
| SCCOL nColCnt = SCCOL_MAX; |
| SCROW nRowCnt = rInsPos.Row(); |
| DifAttrCache aAttrCache( bPlain ); |
| |
| DATASET eAkt = D_UNKNOWN; |
| |
| while( eAkt != D_EOD ) |
| { |
| eAkt = aDifParser.GetNextDataset(); |
| |
| aPrgrsBar.Progress(); |
| |
| switch( eAkt ) |
| { |
| case D_BOT: |
| if( nColCnt < SCCOL_MAX ) |
| nRowCnt++; |
| nColCnt = nBaseCol; |
| break; |
| case D_EOD: |
| break; |
| case D_NUMERIC: // Numbercell |
| if( nColCnt == SCCOL_MAX ) |
| nColCnt = nBaseCol; |
| |
| if( ValidCol(nColCnt) && ValidRow(nRowCnt) ) |
| { |
| ScBaseCell* pCell; |
| if( DifParser::IsV( rData.GetBuffer() ) ) |
| { |
| pCell = new ScValueCell( aDifParser.fVal ); |
| if( !bPlain ) |
| aAttrCache.SetNumFormat( nColCnt, nRowCnt, |
| aDifParser.nNumFormat ); |
| } |
| else if( rData == pKeyTRUE || rData == pKeyFALSE ) |
| { |
| pCell = new ScValueCell( aDifParser.fVal ); |
| if( bPlain ) |
| aAttrCache.SetLogical( nColCnt, nRowCnt ); |
| else |
| aAttrCache.SetNumFormat( nColCnt, nRowCnt, |
| aDifParser.nNumFormat ); |
| } |
| else if( rData == pKeyNA || rData == pKeyERROR ) |
| pCell = new ScStringCell( rData ); |
| else |
| { |
| String aTmp( RTL_CONSTASCII_USTRINGPARAM( "#IND: " )); |
| aTmp += rData; |
| aTmp += sal_Unicode('?'); |
| pCell = new ScStringCell( aTmp ); |
| } |
| |
| pDoc->PutCell( nColCnt, nRowCnt, nBaseTab, pCell, ( sal_Bool ) sal_True ); |
| } |
| else |
| bOverflowWarn = sal_True; |
| |
| nColCnt++; |
| break; |
| case D_STRING: // Textcell |
| if( nColCnt == SCCOL_MAX ) |
| nColCnt = nBaseCol; |
| |
| if( ValidCol(nColCnt) && ValidRow(nRowCnt) ) |
| { |
| if( rData.Len() > 0 ) |
| { |
| pDoc->PutCell( nColCnt, nRowCnt, nBaseTab, |
| ScBaseCell::CreateTextCell( rData, pDoc ), ( sal_Bool ) sal_True ); |
| } |
| } |
| else |
| bOverflowWarn = sal_True; |
| |
| nColCnt++; |
| break; |
| case D_UNKNOWN: |
| break; |
| case D_SYNT_ERROR: |
| break; |
| default: |
| DBG_ERROR( "ScImportDif - missing enum" ); |
| } |
| } |
| |
| aAttrCache.Apply( *pDoc, nBaseTab ); |
| } |
| else |
| return eERR_FORMAT; |
| |
| if( bSyntErrWarn ) |
| //############################################### |
| // ACHTUNG: Hier fehlt noch die richtige Warnung! |
| return eERR_RNGOVRFLW; |
| //############################################### |
| else if( bOverflowWarn ) |
| return eERR_RNGOVRFLW; |
| else |
| return eERR_OK; |
| } |
| |
| |
| DifParser::DifParser( SvStream& rNewIn, const sal_uInt32 nOption, ScDocument& rDoc, CharSet e ) : |
| rIn( rNewIn ) |
| { |
| eCharSet = e; |
| if ( rIn.GetStreamCharSet() != eCharSet ) |
| { |
| DBG_ERRORFILE( "CharSet passed overrides and modifies StreamCharSet" ); |
| rIn.SetStreamCharSet( eCharSet ); |
| } |
| rIn.StartReadingUnicodeText( eCharSet ); |
| |
| bPlain = ( nOption == SC_DIFOPT_PLAIN ); |
| |
| if( bPlain ) |
| pNumFormatter = NULL; |
| else |
| pNumFormatter = rDoc.GetFormatTable(); |
| } |
| |
| |
| TOPIC DifParser::GetNextTopic( void ) |
| { |
| enum STATE { S_VectorVal, S_Data, S_END, S_START, S_UNKNOWN, S_ERROR_L2 }; |
| |
| static const sal_Unicode pKeyLABEL[] = { 'L', 'A', 'B', 'E', 'L', 0 }; |
| static const sal_Unicode pKeyCOMMENT[] = { 'C', 'O', 'M', 'M', 'E', 'N', 'T', 0 }; |
| static const sal_Unicode pKeySIZE[] = { 'S', 'I', 'Z', 'E', 0 }; |
| static const sal_Unicode pKeyPERIODICITY[] = { 'P', 'E', 'R', 'I', 'O', 'D', 'I', 'C', 'I', 'T', 'Y', 0 }; |
| static const sal_Unicode pKeyMAJORSTART[] = { 'M', 'A', 'J', 'O', 'R', 'S', 'T', 'A', 'R', 'T', 0 }; |
| static const sal_Unicode pKeyMINORSTART[] = { 'M', 'I', 'N', 'O', 'R', 'S', 'T', 'A', 'R', 'T', 0 }; |
| static const sal_Unicode pKeyTRUELENGTH[] = { 'T', 'R', 'U', 'E', 'L', 'E', 'N', 'G', 'T', 'H', 0 }; |
| static const sal_Unicode pKeyUINITS[] = { 'U', 'I', 'N', 'I', 'T', 'S', 0 }; |
| static const sal_Unicode pKeyDISPLAYUNITS[] = { 'D', 'I', 'S', 'P', 'L', 'A', 'Y', 'U', 'N', 'I', 'T', 'S', 0 }; |
| static const sal_Unicode pKeyUNKNOWN[] = { 0 }; |
| |
| static const sal_Unicode* ppKeys[] = |
| { |
| pKeyTABLE, // 0 |
| pKeyVECTORS, |
| pKeyTUPLES, |
| pKeyDATA, |
| pKeyLABEL, |
| pKeyCOMMENT, // 5 |
| pKeySIZE, |
| pKeyPERIODICITY, |
| pKeyMAJORSTART, |
| pKeyMINORSTART, |
| pKeyTRUELENGTH, // 10 |
| pKeyUINITS, |
| pKeyDISPLAYUNITS, |
| pKeyUNKNOWN // 13 |
| }; |
| |
| static const TOPIC pTopics[] = |
| { |
| T_TABLE, // 0 |
| T_VECTORS, |
| T_TUPLES, |
| T_DATA, |
| T_LABEL, |
| T_COMMENT, // 5 |
| T_SIZE, |
| T_PERIODICITY, |
| T_MAJORSTART, |
| T_MINORSTART, |
| T_TRUELENGTH, // 10 |
| T_UINITS, |
| T_DISPLAYUNITS, |
| T_UNKNOWN // 13 |
| }; |
| |
| STATE eS = S_START; |
| String aLine; |
| |
| nVector = 0; |
| nVal = 0; |
| TOPIC eRet = T_UNKNOWN; |
| |
| while( eS != S_END ) |
| { |
| if( !ReadNextLine( aLine ) ) |
| { |
| eS = S_END; |
| eRet = T_END; |
| } |
| |
| switch( eS ) |
| { |
| case S_START: |
| { |
| const sal_Unicode* pRef; |
| sal_uInt16 nCnt = 0; |
| sal_Bool bSearch = sal_True; |
| |
| pRef = ppKeys[ nCnt ]; |
| |
| while( bSearch ) |
| { |
| if( aLine == pRef ) |
| { |
| eRet = pTopics[ nCnt ]; |
| bSearch = sal_False; |
| } |
| else |
| { |
| nCnt++; |
| pRef = ppKeys[ nCnt ]; |
| if( !*pRef ) |
| bSearch = sal_False; |
| } |
| } |
| |
| if( *pRef ) |
| eS = S_VectorVal; |
| else |
| eS = S_UNKNOWN; |
| } |
| break; |
| case S_VectorVal: |
| { |
| const sal_Unicode* pCur = aLine.GetBuffer(); |
| |
| pCur = ScanIntVal( pCur, nVector ); |
| |
| if( pCur && *pCur == ',' ) |
| { |
| pCur++; |
| ScanIntVal( pCur, nVal ); |
| eS = S_Data; |
| } |
| else |
| eS = S_ERROR_L2; |
| } |
| break; |
| case S_Data: |
| DBG_ASSERT( aLine.Len() >= 2, |
| "+GetNextTopic(): <String> ist zu kurz!" ); |
| if( aLine.Len() > 2 ) |
| aData = aLine.Copy( 1, aLine.Len() - 2 ); |
| else |
| aData.Erase(); |
| eS = S_END; |
| break; |
| case S_END: |
| DBG_ERRORFILE( "DifParser::GetNextTopic - unexpected state" ); |
| break; |
| case S_UNKNOWN: |
| // 2 Zeilen ueberlesen |
| ReadNextLine( aLine ); |
| case S_ERROR_L2: // Fehler in Line 2 aufgetreten |
| // eine Zeile ueberlesen |
| ReadNextLine( aLine ); |
| eS = S_END; |
| break; |
| default: |
| DBG_ERRORFILE( "DifParser::GetNextTopic - missing enum" ); |
| } |
| } |
| |
| return eRet; |
| } |
| |
| |
| static void lcl_DeEscapeQuotesDif( String& rString ) |
| { |
| // Special handling for DIF import: Escaped (duplicated) quotes are resolved. |
| // Single quote characters are left in place because older versions didn't |
| // escape quotes in strings (and Excel doesn't when using the clipboard). |
| // The quotes around the string are removed before this function is called. |
| |
| static const sal_Unicode aDQ[] = { '"', '"', 0 }; |
| xub_StrLen nPos = 0; |
| while ( (nPos = rString.Search( aDQ, nPos )) != STRING_NOTFOUND ) |
| { |
| rString.Erase( nPos, 1 ); |
| ++nPos; |
| } |
| } |
| |
| // Determine if passed in string is numeric data and set fVal/nNumFormat if so |
| DATASET DifParser::GetNumberDataset( const sal_Unicode* pPossibleNumericData ) |
| { |
| DATASET eRet = D_SYNT_ERROR; |
| if( bPlain ) |
| { |
| if( ScanFloatVal( pPossibleNumericData ) ) |
| eRet = D_NUMERIC; |
| else |
| eRet = D_SYNT_ERROR; |
| } |
| else |
| { // ...und zur Strafe mit'm Numberformatter... |
| DBG_ASSERT( pNumFormatter, "-DifParser::GetNextDataset(): No Formatter, more fun!" ); |
| String aTestVal( pPossibleNumericData ); |
| sal_uInt32 nFormat = 0; |
| double fTmpVal; |
| if( pNumFormatter->IsNumberFormat( aTestVal, nFormat, fTmpVal ) ) |
| { |
| fVal = fTmpVal; |
| nNumFormat = nFormat; |
| eRet = D_NUMERIC; |
| } |
| else |
| eRet = D_SYNT_ERROR; |
| } |
| return eRet; |
| } |
| |
| bool DifParser::ReadNextLine( String& rStr ) |
| { |
| if( aLookAheadLine.Len() == 0 ) |
| { |
| return rIn.ReadUniOrByteStringLine( rStr ); |
| } |
| else |
| { |
| rStr = aLookAheadLine; |
| aLookAheadLine.Erase(); |
| return true; |
| } |
| } |
| |
| // Look ahead in the stream to determine if the next line is the first line of |
| // a valid data record structure |
| bool DifParser::LookAhead() |
| { |
| const sal_Unicode* pAktBuffer; |
| bool bValidStructure = false; |
| |
| DBG_ASSERT( aLookAheadLine.Len() == 0, "*DifParser::LookAhead(): LookAhead called twice in a row" ); |
| rIn.ReadUniOrByteStringLine( aLookAheadLine ); |
| |
| pAktBuffer = aLookAheadLine.GetBuffer(); |
| |
| switch( *pAktBuffer ) |
| { |
| case '-': // Special Datatype |
| pAktBuffer++; |
| |
| if( Is1_0( pAktBuffer ) ) |
| { |
| bValidStructure = true; |
| } |
| break; |
| case '0': // Numeric Data |
| pAktBuffer++; |
| if( *pAktBuffer == ',' ) |
| { |
| pAktBuffer++; |
| bValidStructure = ( GetNumberDataset(pAktBuffer) != D_SYNT_ERROR ); |
| } |
| break; |
| case '1': // String Data |
| if( Is1_0( aLookAheadLine.GetBuffer() ) ) |
| { |
| bValidStructure = true; |
| } |
| break; |
| } |
| return bValidStructure; |
| } |
| |
| DATASET DifParser::GetNextDataset( void ) |
| { |
| DATASET eRet = D_UNKNOWN; |
| String aLine; |
| const sal_Unicode* pAktBuffer; |
| |
| ReadNextLine( aLine ); |
| |
| pAktBuffer = aLine.GetBuffer(); |
| |
| switch( *pAktBuffer ) |
| { |
| case '-': // Special Datatype |
| pAktBuffer++; |
| |
| if( Is1_0( pAktBuffer ) ) |
| { |
| ReadNextLine( aLine ); |
| if( IsBOT( aLine.GetBuffer() ) ) |
| eRet = D_BOT; |
| else if( IsEOD( aLine.GetBuffer() ) ) |
| eRet = D_EOD; |
| } |
| break; |
| case '0': // Numeric Data |
| pAktBuffer++; // Wert in fVal, 2. Zeile in aData |
| if( *pAktBuffer == ',' ) |
| { |
| pAktBuffer++; |
| eRet = GetNumberDataset(pAktBuffer); |
| ReadNextLine( aData ); |
| if ( eRet == D_SYNT_ERROR ) |
| { // for broken records write "#ERR: data" to cell |
| String aTmp( RTL_CONSTASCII_USTRINGPARAM( "#ERR: " )); |
| aTmp += pAktBuffer; |
| aTmp.AppendAscii( " (" ); |
| aTmp += aData; |
| aTmp += sal_Unicode(')'); |
| aData = aTmp; |
| eRet = D_STRING; |
| } |
| } |
| break; |
| case '1': // String Data |
| if( Is1_0( aLine.GetBuffer() ) ) |
| { |
| ReadNextLine( aLine ); |
| xub_StrLen nLineLength = aLine.Len(); |
| const sal_Unicode* pLine = aLine.GetBuffer(); |
| |
| if( nLineLength >= 1 && *pLine == '"' ) |
| { |
| // Quotes are not always escaped (duplicated), see lcl_DeEscapeQuotesDif |
| // A look ahead into the next line is needed in order to deal with |
| // multiline strings containing quotes |
| if( LookAhead() ) |
| { |
| // Single line string |
| if( nLineLength >= 2 && pLine[nLineLength - 1] == '"' ) |
| { |
| aData = aLine.Copy( 1, nLineLength - 2 ); |
| lcl_DeEscapeQuotesDif( aData ); |
| eRet = D_STRING; |
| } |
| } |
| else |
| { |
| // Multiline string |
| aData = aLine.Copy( 1 ); |
| bool bContinue = true; |
| while ( bContinue ) |
| { |
| aData.Append( '\n' ); |
| bContinue = !rIn.IsEof() && ReadNextLine( aLine ); |
| if( bContinue ) |
| { |
| nLineLength = aLine.Len(); |
| if( nLineLength >= 1 ) |
| { |
| pLine = aLine.GetBuffer(); |
| bContinue = !LookAhead(); |
| if( bContinue ) |
| { |
| aData.Append( aLine ); |
| } |
| else if( pLine[nLineLength - 1] == '"' ) |
| { |
| aData.Append( pLine, nLineLength - 1 ); |
| lcl_DeEscapeQuotesDif( aData ); |
| eRet = D_STRING; |
| } |
| } |
| } |
| }; |
| } |
| } |
| } |
| break; |
| } |
| |
| if( eRet == D_UNKNOWN ) |
| ReadNextLine( aLine ); |
| |
| if( rIn.IsEof() ) |
| eRet = D_EOD; |
| |
| return eRet; |
| } |
| |
| |
| const sal_Unicode* DifParser::ScanIntVal( const sal_Unicode* pStart, sal_uInt32& rRet ) |
| { |
| // eat leading whitespace, not specified, but seen in the wild |
| while (*pStart == ' ' || *pStart == '\t') |
| ++pStart; |
| |
| sal_Unicode cAkt = *pStart; |
| |
| if( IsNumber( cAkt ) ) |
| rRet = ( sal_uInt32 ) ( cAkt - '0' ); |
| else |
| return NULL; |
| |
| pStart++; |
| cAkt = *pStart; |
| |
| while( IsNumber( cAkt ) && rRet < ( 0xFFFFFFFF / 10 ) ) |
| { |
| rRet *= 10; |
| rRet += ( sal_uInt32 ) ( cAkt - '0' ); |
| |
| pStart++; |
| cAkt = *pStart; |
| } |
| |
| return pStart; |
| } |
| |
| |
| sal_Bool DifParser::ScanFloatVal( const sal_Unicode* pStart ) |
| { |
| double fNewVal = 0.0; |
| sal_Bool bNeg = sal_False; |
| double fFracPos = 1.0; |
| sal_Int32 nExp = 0; |
| sal_Bool bExpNeg = sal_False; |
| sal_Bool bExpOverflow = sal_False; |
| static const sal_uInt16 nExpLimit = 4096; // ACHTUNG: muss genauer ermittelt werden! |
| |
| sal_Unicode cAkt; |
| sal_Bool bRet = sal_False; |
| |
| enum STATE { S_FIRST, S_PRE, S_POST, S_EXP_FIRST, S_EXP, S_END, S_FINDEND }; |
| |
| STATE eS = S_FIRST; |
| |
| fNewVal = 0.0; |
| |
| while( eS != S_END ) |
| { |
| cAkt = *pStart; |
| switch( eS ) |
| { |
| case S_FIRST: |
| if( IsNumber( cAkt ) ) |
| { |
| fNewVal *= 10; |
| fNewVal += cAkt - '0'; |
| eS = S_PRE; |
| } |
| else |
| { |
| switch( cAkt ) |
| { |
| case ' ': |
| case '\t': |
| case '+': |
| break; |
| case '-': |
| bNeg = !bNeg; |
| break; |
| case '.': |
| case ',': //! |
| eS = S_POST; |
| fFracPos = 0.1; |
| break; |
| default: |
| eS = S_END; |
| } |
| } |
| break; |
| case S_PRE: |
| if( IsNumber( cAkt ) ) |
| { |
| fNewVal *= 10; |
| fNewVal += cAkt - '0'; |
| } |
| else |
| { |
| switch( cAkt ) |
| { |
| case '.': |
| case ',': //! |
| eS = S_POST; |
| fFracPos = 0.1; |
| break; |
| case 'e': |
| case 'E': |
| eS = S_EXP; |
| break; |
| case 0x00: // IsNumberEnding( cAkt ) |
| bRet = sal_True; // no |
| default: // break! |
| eS = S_END; |
| } |
| } |
| break; |
| case S_POST: |
| if( IsNumber( cAkt ) ) |
| { |
| fNewVal += fFracPos * ( cAkt - '0' ); |
| fFracPos /= 10.0; |
| } |
| else |
| { |
| switch( cAkt ) |
| { |
| case 'e': |
| case 'E': |
| eS = S_EXP_FIRST; |
| break; |
| case 0x00: // IsNumberEnding( cAkt ) |
| bRet = sal_True; // no |
| default: // break! |
| eS = S_END; |
| } |
| } |
| break; |
| case S_EXP_FIRST: |
| if( IsNumber( cAkt ) ) |
| { |
| if( nExp < nExpLimit ) |
| { |
| nExp *= 10; |
| nExp += ( sal_uInt16 ) ( cAkt - '0' ); |
| } |
| eS = S_EXP; |
| } |
| else |
| { |
| switch( cAkt ) |
| { |
| case '+': |
| break; |
| case '-': |
| bExpNeg = !bExpNeg; |
| break; |
| default: |
| eS = S_END; |
| } |
| } |
| break; |
| case S_EXP: |
| if( IsNumber( cAkt ) ) |
| { |
| if( nExp < ( 0xFFFF / 10 ) ) |
| { |
| nExp *= 10; |
| nExp += ( sal_uInt16 ) ( cAkt - '0' ); |
| } |
| else |
| { |
| bExpOverflow = sal_True; |
| eS = S_FINDEND; |
| } |
| } |
| else |
| { |
| bRet = IsNumberEnding( cAkt ); |
| eS = S_END; |
| } |
| break; |
| case S_FINDEND: |
| if( IsNumberEnding( cAkt ) ) |
| { |
| bRet = sal_True; // damit sinnvoll weitergeparst werden kann |
| eS = S_END; |
| } |
| break; |
| case S_END: |
| DBG_ERRORFILE( "DifParser::ScanFloatVal - unexpected state" ); |
| break; |
| default: |
| DBG_ERRORFILE( "DifParser::ScanFloatVal - missing enum" ); |
| } |
| pStart++; |
| } |
| |
| if( bRet ) |
| { |
| if( bExpOverflow ) |
| return sal_False; // ACHTUNG: hier muss noch differenziert werden |
| |
| if( bNeg ) |
| fNewVal *= 1.0; |
| |
| if( bExpNeg ) |
| nExp *= -1; |
| |
| if( nExp != 0 ) |
| fNewVal *= pow( 10.0, ( double ) nExp ); |
| fVal = fNewVal; |
| } |
| |
| return bRet; |
| } |
| |
| |
| DifColumn::~DifColumn( void ) |
| { |
| ENTRY* pEntry = ( ENTRY* ) List::First(); |
| |
| while( pEntry ) |
| { |
| delete pEntry; |
| pEntry = ( ENTRY* ) List::Next(); |
| } |
| } |
| |
| |
| void DifColumn::SetLogical( SCROW nRow ) |
| { |
| DBG_ASSERT( ValidRow(nRow), "*DifColumn::SetLogical(): Row zu gross!" ); |
| |
| if( pAkt ) |
| { |
| DBG_ASSERT( nRow > 0, "*DifColumn::SetLogical(): weitere koennen nicht 0 sein!" ); |
| nRow--; |
| if( pAkt->nEnd == nRow ) |
| pAkt->nEnd++; |
| else |
| pAkt = NULL; |
| } |
| else |
| { |
| pAkt = new ENTRY; |
| pAkt->nStart = pAkt->nEnd = nRow; |
| List::Insert( pAkt, LIST_APPEND ); |
| } |
| } |
| |
| |
| void DifColumn::SetNumFormat( SCROW nRow, const sal_uInt32 nNumFormat ) |
| { |
| DBG_ASSERT( ValidRow(nRow), "*DifColumn::SetNumFormat(): Row zu gross!" ); |
| |
| if( nNumFormat > 0 ) |
| { |
| if( pAkt ) |
| { |
| DBG_ASSERT( nRow > 0, |
| "*DifColumn::SetNumFormat(): weitere koennen nicht 0 sein!" ); |
| DBG_ASSERT( nRow > pAkt->nEnd, |
| "*DifColumn::SetNumFormat(): Noch 'mal von vorne?" ); |
| |
| if( pAkt->nNumFormat == nNumFormat && pAkt->nEnd == nRow - 1 ) |
| pAkt->nEnd = nRow; |
| else |
| NewEntry( nRow, nNumFormat ); |
| } |
| else |
| NewEntry( nRow, nNumFormat ); |
| } |
| else |
| pAkt = NULL; |
| } |
| |
| |
| void DifColumn::NewEntry( const SCROW nPos, const sal_uInt32 nNumFormat ) |
| { |
| pAkt = new ENTRY; |
| pAkt->nStart = pAkt->nEnd = nPos; |
| pAkt->nNumFormat = nNumFormat; |
| List::Insert( pAkt, LIST_APPEND ); |
| } |
| |
| |
| void DifColumn::Apply( ScDocument& rDoc, const SCCOL nCol, const SCTAB nTab, const ScPatternAttr& rPattAttr ) |
| { |
| ENTRY* pEntry = ( ENTRY* ) List::First(); |
| |
| while( pEntry ) |
| { |
| rDoc.ApplyPatternAreaTab( nCol, pEntry->nStart, nCol, pEntry->nEnd, |
| nTab, rPattAttr ); |
| pEntry = ( ENTRY* ) List::Next(); |
| } |
| } |
| |
| |
| void DifColumn::Apply( ScDocument& rDoc, const SCCOL nCol, const SCTAB nTab ) |
| { |
| ScPatternAttr aAttr( rDoc.GetPool() ); |
| SfxItemSet& rItemSet = aAttr.GetItemSet(); |
| |
| ENTRY* pEntry = ( ENTRY* ) List::First(); |
| |
| while( pEntry ) |
| { |
| DBG_ASSERT( pEntry->nNumFormat > 0, |
| "+DifColumn::Apply(): Numberformat darf hier nicht 0 sein!" ); |
| rItemSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, pEntry->nNumFormat ) ); |
| |
| rDoc.ApplyPatternAreaTab( nCol, pEntry->nStart, nCol, pEntry->nEnd, nTab, aAttr ); |
| |
| rItemSet.ClearItem(); |
| |
| pEntry = ( ENTRY* ) List::Next(); |
| } |
| } |
| |
| |
| DifAttrCache::DifAttrCache( const sal_Bool bNewPlain ) |
| { |
| bPlain = bNewPlain; |
| ppCols = new DifColumn *[ MAXCOL + 1 ]; |
| for( SCCOL nCnt = 0 ; nCnt <= MAXCOL ; nCnt++ ) |
| ppCols[ nCnt ] = NULL; |
| } |
| |
| |
| DifAttrCache::~DifAttrCache() |
| { |
| for( SCCOL nCnt = 0 ; nCnt <= MAXCOL ; nCnt++ ) |
| { |
| if( ppCols[ nCnt ] ) |
| delete ppCols[ nCnt ]; |
| } |
| } |
| |
| |
| void DifAttrCache::SetNumFormat( const SCCOL nCol, const SCROW nRow, const sal_uInt32 nNumFormat ) |
| { |
| DBG_ASSERT( ValidCol(nCol), "-DifAttrCache::SetNumFormat(): Col zu gross!" ); |
| DBG_ASSERT( !bPlain, "*DifAttrCache::SetNumFormat(): sollte nicht Plain sein!" ); |
| |
| if( !ppCols[ nCol ] ) |
| ppCols[ nCol ] = new DifColumn; |
| |
| ppCols[ nCol ]->SetNumFormat( nRow, nNumFormat ); |
| } |
| |
| |
| void DifAttrCache::Apply( ScDocument& rDoc, SCTAB nTab ) |
| { |
| if( bPlain ) |
| { |
| ScPatternAttr* pPatt = NULL; |
| |
| for( SCCOL nCol = 0 ; nCol <= MAXCOL ; nCol++ ) |
| { |
| if( ppCols[ nCol ] ) |
| { |
| if( !pPatt ) |
| { |
| pPatt = new ScPatternAttr( rDoc.GetPool() ); |
| pPatt->GetItemSet().Put( SfxUInt32Item( ATTR_VALUE_FORMAT, |
| rDoc.GetFormatTable()->GetStandardFormat( NUMBERFORMAT_LOGICAL ) ) ); |
| } |
| |
| ppCols[ nCol ]->Apply( rDoc, nCol, nTab, *pPatt ); |
| } |
| } |
| |
| if( pPatt ) |
| delete pPatt; |
| } |
| else |
| { |
| for( SCCOL nCol = 0 ; nCol <= MAXCOL ; nCol++ ) |
| { |
| if( ppCols[ nCol ] ) |
| ppCols[ nCol ]->Apply( rDoc, nCol, nTab ); |
| } |
| } |
| } |
| |
| |
| |
