?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sc / source / filter / dif / difimp.cxx
blob723ee3098a613b43e5c1097d57840b33ed8c4d07
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: difimp.cxx,v $
10 * $Revision: 1.15 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34 //------------------------------------------------------------------------
35
36 #include "scitems.hxx"
37 #include <svtools/zforlist.hxx>
38
39 #include "dif.hxx"
40 #include "filter.hxx"
41 #include "fprogressbar.hxx"
42 #include "scerrors.hxx"
43 #include "document.hxx"
44 #include "cell.hxx"
45 #include "patattr.hxx"
46 #include "docpool.hxx"
47 #include "attrib.hxx"
48 #include "ftools.hxx"
49
50 #include <math.h>
51
52 const sal_Unicode pKeyTABLE[] = { 'T', 'A', 'B', 'L', 'E', 0 };
53 const sal_Unicode pKeyVECTORS[] = { 'V', 'E', 'C', 'T', 'O', 'R', 'S', 0 };
54 const sal_Unicode pKeyTUPLES[] = { 'T', 'U', 'P', 'L', 'E', 'S', 0 };
55 const sal_Unicode pKeyDATA[] = { 'D', 'A', 'T', 'A', 0 };
56 const sal_Unicode pKeyBOT[] = { 'B', 'O', 'T', 0 };
57 const sal_Unicode pKeyEOD[] = { 'E', 'O', 'D', 0 };
58 const sal_Unicode pKeyERROR[] = { 'E', 'R', 'R', 'O', 'R', 0 };
59 const sal_Unicode pKeyTRUE[] = { 'T', 'R', 'U', 'E', 0 };
60 const sal_Unicode pKeyFALSE[] = { 'F', 'A', 'L', 'S', 'E', 0 };
61 const sal_Unicode pKeyNA[] = { 'N', 'A', 0 };
62 const sal_Unicode pKeyV[] = { 'V', 0 };
63 const sal_Unicode pKey1_0[] = { '1', ',', '0', 0 };
64
65
66 FltError ScFormatFilterPluginImpl::ScImportDif( SvStream& rIn, ScDocument* pDoc, const ScAddress& rInsPos,
67 const CharSet eVon, UINT32 nDifOption )
68 {
69 DifParser aDifParser( rIn, nDifOption, *pDoc, eVon );
70
71 const BOOL bPlain = aDifParser.IsPlain();
72
73 SCTAB nBaseTab = rInsPos.Tab();
74
75 TOPIC eTopic = T_UNKNOWN;
76 BOOL bSyntErrWarn = FALSE;
77 BOOL bOverflowWarn = FALSE;
78
79 String& rData = aDifParser.aData;
80 BOOL bData = FALSE;
81
82 SCCOL nNumCols = 0;
83 SCROW nNumRows = 0;
84
85 rIn.Seek( 0 );
86
87 ScfStreamProgressBar aPrgrsBar( rIn, pDoc->GetDocumentShell() );
88
89 while( eTopic != T_DATA && eTopic != T_END )
90 {
91 eTopic = aDifParser.GetNextTopic();
92
93 aPrgrsBar.Progress();
94
95 bData = rData.Len() > 0;
96
97 switch( eTopic )
98 {
99 case T_TABLE:
100 {
101 if( aDifParser.nVector != 0 || aDifParser.nVal != 1 )
102 bSyntErrWarn = TRUE;
103 if( bData )
104 pDoc->RenameTab( nBaseTab, rData );
105 }
106 break;
107 case T_VECTORS:
108 {
109 if( aDifParser.nVector != 0 )
110 bSyntErrWarn = TRUE;
111 if( aDifParser.nVal > MAXCOL + 1 )
112 nNumCols = SCCOL_MAX;
113 else
114 nNumCols = static_cast<SCCOL>(aDifParser.nVal);
115 }
116 break;
117 case T_TUPLES:
118 {
119 if( aDifParser.nVector != 0 )
120 bSyntErrWarn = TRUE;
121 if( aDifParser.nVal > MAXROW + 1 )
122 nNumRows = SCROW_MAX;
123 else
124 nNumRows = static_cast<SCROW>(aDifParser.nVal);
125 }
126 break;
127 case T_DATA:
128 {
129 if( aDifParser.nVector != 0 || aDifParser.nVal != 0 )
130 bSyntErrWarn = TRUE;
131 }
132 break;
133 case T_LABEL:
134 case T_COMMENT:
135 case T_SIZE:
136 case T_PERIODICITY:
137 case T_MAJORSTART:
138 case T_MINORSTART:
139 case T_TRUELENGTH:
140 case T_UINITS:
141 case T_DISPLAYUNITS:
142 case T_END:
143 case T_UNKNOWN:
144 break;
145 default:
146 DBG_ERRORFILE( "ScImportDif - missing enum" );
147 }
148
149 }
150
151
152 if( eTopic == T_DATA )
153 { // Ab hier kommen die Daten
154 SCCOL nBaseCol = rInsPos.Col();
155
156 SCCOL nColCnt = SCCOL_MAX;
157 SCROW nRowCnt = rInsPos.Row();
158 DifAttrCache aAttrCache( bPlain );
159
160 DATASET eAkt = D_UNKNOWN;
161
162 while( eAkt != D_EOD )
163 {
164 eAkt = aDifParser.GetNextDataset();
165
166 aPrgrsBar.Progress();
167
168 switch( eAkt )
169 {
170 case D_BOT:
171 if( nColCnt < SCCOL_MAX )
172 nRowCnt++;
173 nColCnt = nBaseCol;
174 break;
175 case D_EOD:
176 break;
177 case D_NUMERIC: // Numbercell
178 if( nColCnt == SCCOL_MAX )
179 nColCnt = nBaseCol;
180
181 if( ValidCol(nColCnt) && ValidRow(nRowCnt) )
182 {
183 ScBaseCell* pCell;
184 if( DifParser::IsV( rData.GetBuffer() ) )
185 {
186 pCell = new ScValueCell( aDifParser.fVal );
187 if( !bPlain )
188 aAttrCache.SetNumFormat( nColCnt, nRowCnt,
189 aDifParser.nNumFormat );
190 }
191 else if( rData == pKeyTRUE || rData == pKeyFALSE )
192 {
193 pCell = new ScValueCell( aDifParser.fVal );
194 if( bPlain )
195 aAttrCache.SetLogical( nColCnt, nRowCnt );
196 else
197 aAttrCache.SetNumFormat( nColCnt, nRowCnt,
198 aDifParser.nNumFormat );
199 }
200 else if( rData == pKeyNA || rData == pKeyERROR )
201 pCell = new ScStringCell( rData );
202 else
203 {
204 String aTmp( RTL_CONSTASCII_USTRINGPARAM( "#IND: " ));
205 aTmp += rData;
206 aTmp += sal_Unicode('?');
207 pCell = new ScStringCell( aTmp );
208 }
209
210 pDoc->PutCell( nColCnt, nRowCnt, nBaseTab, pCell, ( BOOL ) TRUE );
211 }
212 else
213 bOverflowWarn = TRUE;
214
215 nColCnt++;
216 break;
217 case D_STRING: // Textcell
218 if( nColCnt == SCCOL_MAX )
219 nColCnt = nBaseCol;
220
221 if( ValidCol(nColCnt) && ValidRow(nRowCnt) )
222 {
223 if( rData.Len() > 0 )
224 {
225 pDoc->PutCell( nColCnt, nRowCnt, nBaseTab,
226 ScBaseCell::CreateTextCell( rData, pDoc ), ( BOOL ) TRUE );
227 }
228 }
229 else
230 bOverflowWarn = TRUE;
231
232 nColCnt++;
233 break;
234 case D_UNKNOWN:
235 break;
236 case D_SYNT_ERROR:
237 break;
238 default:
239 DBG_ERROR( "ScImportDif - missing enum" );
240 }
241 }
242
243 aAttrCache.Apply( *pDoc, nBaseTab );
244 }
245 else
246 return eERR_FORMAT;
247
248 if( bSyntErrWarn )
249 //###############################################
250 // ACHTUNG: Hier fehlt noch die richtige Warnung!
251 return eERR_RNGOVRFLW;
252 //###############################################
253 else if( bOverflowWarn )
254 return eERR_RNGOVRFLW;
255 else
256 return eERR_OK;
257 }
258
259
260 DifParser::DifParser( SvStream& rNewIn, const UINT32 nOption, ScDocument& rDoc, CharSet e ) :
261 rIn( rNewIn )
262 {
263 eCharSet = e;
264 if ( rIn.GetStreamCharSet() != eCharSet )
265 {
266 DBG_ERRORFILE( "CharSet passed overrides and modifies StreamCharSet" );
267 rIn.SetStreamCharSet( eCharSet );
268 }
269 if ( eCharSet == RTL_TEXTENCODING_UNICODE )
270 rIn.StartReadingUnicodeText();
271
272 bPlain = ( nOption == SC_DIFOPT_PLAIN );
273
274 if( bPlain )
275 pNumFormatter = NULL;
276 else
277 pNumFormatter = rDoc.GetFormatTable();
278 }
279
280
281 TOPIC DifParser::GetNextTopic( void )
282 {
283 enum STATE { S_VectorVal, S_Data, S_END, S_START, S_UNKNOWN, S_ERROR_L2 };
284
285 static const sal_Unicode pKeyLABEL[] = { 'L', 'A', 'B', 'E', 'L', 0 };
286 static const sal_Unicode pKeyCOMMENT[] = { 'C', 'O', 'M', 'M', 'E', 'N', 'T', 0 };
287 static const sal_Unicode pKeySIZE[] = { 'S', 'I', 'Z', 'E', 0 };
288 static const sal_Unicode pKeyPERIODICITY[] = { 'P', 'E', 'R', 'I', 'O', 'D', 'I', 'C', 'I', 'T', 'Y', 0 };
289 static const sal_Unicode pKeyMAJORSTART[] = { 'M', 'A', 'J', 'O', 'R', 'S', 'T', 'A', 'R', 'T', 0 };
290 static const sal_Unicode pKeyMINORSTART[] = { 'M', 'I', 'N', 'O', 'R', 'S', 'T', 'A', 'R', 'T', 0 };
291 static const sal_Unicode pKeyTRUELENGTH[] = { 'T', 'R', 'U', 'E', 'L', 'E', 'N', 'G', 'T', 'H', 0 };
292 static const sal_Unicode pKeyUINITS[] = { 'U', 'I', 'N', 'I', 'T', 'S', 0 };
293 static const sal_Unicode pKeyDISPLAYUNITS[] = { 'D', 'I', 'S', 'P', 'L', 'A', 'Y', 'U', 'N', 'I', 'T', 'S', 0 };
294 static const sal_Unicode pKeyUNKNOWN[] = { 0 };
295
296 static const sal_Unicode* ppKeys[] =
297 {
298 pKeyTABLE, // 0
299 pKeyVECTORS,
300 pKeyTUPLES,
301 pKeyDATA,
302 pKeyLABEL,
303 pKeyCOMMENT, // 5
304 pKeySIZE,
305 pKeyPERIODICITY,
306 pKeyMAJORSTART,
307 pKeyMINORSTART,
308 pKeyTRUELENGTH, // 10
309 pKeyUINITS,
310 pKeyDISPLAYUNITS,
311 pKeyUNKNOWN // 13
312 };
313
314 static const TOPIC pTopics[] =
315 {
316 T_TABLE, // 0
317 T_VECTORS,
318 T_TUPLES,
319 T_DATA,
320 T_LABEL,
321 T_COMMENT, // 5
322 T_SIZE,
323 T_PERIODICITY,
324 T_MAJORSTART,
325 T_MINORSTART,
326 T_TRUELENGTH, // 10
327 T_UINITS,
328 T_DISPLAYUNITS,
329 T_UNKNOWN // 13
330 };
331
332 STATE eS = S_START;
333 String aLine;
334
335 nVector = 0;
336 nVal = 0;
337 TOPIC eRet = T_UNKNOWN;
338
339 while( eS != S_END )
340 {
341 if( !ReadNextLine( aLine ) )
342 {
343 eS = S_END;
344 eRet = T_END;
345 }
346
347 switch( eS )
348 {
349 case S_START:
350 {
351 const sal_Unicode* pRef;
352 UINT16 nCnt = 0;
353 BOOL bSearch = TRUE;
354
355 pRef = ppKeys[ nCnt ];
356
357 while( bSearch )
358 {
359 if( aLine == pRef )
360 {
361 eRet = pTopics[ nCnt ];
362 bSearch = FALSE;
363 }
364 else
365 {
366 nCnt++;
367 pRef = ppKeys[ nCnt ];
368 if( !*pRef )
369 bSearch = FALSE;
370 }
371 }
372
373 if( *pRef )
374 eS = S_VectorVal;
375 else
376 eS = S_UNKNOWN;
377 }
378 break;
379 case S_VectorVal:
380 {
381 const sal_Unicode* pCur = aLine.GetBuffer();
382
383 pCur = ScanIntVal( pCur, nVector );
384
385 if( pCur && *pCur == ',' )
386 {
387 pCur++;
388 ScanIntVal( pCur, nVal );
389 eS = S_Data;
390 }
391 else
392 eS = S_ERROR_L2;
393 }
394 break;
395 case S_Data:
396 DBG_ASSERT( aLine.Len() >= 2,
397 "+GetNextTopic(): <String> ist zu kurz!" );
398 if( aLine.Len() > 2 )
399 aData = aLine.Copy( 1, aLine.Len() - 2 );
400 else
401 aData.Erase();
402 eS = S_END;
403 break;
404 case S_END:
405 DBG_ERRORFILE( "DifParser::GetNextTopic - unexpected state" );
406 break;
407 case S_UNKNOWN:
408 // 2 Zeilen ueberlesen
409 ReadNextLine( aLine );
410 case S_ERROR_L2: // Fehler in Line 2 aufgetreten
411 // eine Zeile ueberlesen
412 ReadNextLine( aLine );
413 eS = S_END;
414 break;
415 default:
416 DBG_ERRORFILE( "DifParser::GetNextTopic - missing enum" );
417 }
418 }
419
420 return eRet;
421 }
422
423
424 static void lcl_DeEscapeQuotesDif( String& rString )
425 {
426 // Special handling for DIF import: Escaped (duplicated) quotes are resolved.
427 // Single quote characters are left in place because older versions didn't
428 // escape quotes in strings (and Excel doesn't when using the clipboard).
429 // The quotes around the string are removed before this function is called.
430
431 static const sal_Unicode aDQ[] = { '"', '"', 0 };
432 xub_StrLen nPos = 0;
433 while ( (nPos = rString.Search( aDQ, nPos )) != STRING_NOTFOUND )
434 {
435 rString.Erase( nPos, 1 );
436 ++nPos;
437 }
438 }
439
440 // Determine if passed in string is numeric data and set fVal/nNumFormat if so
441 DATASET DifParser::GetNumberDataset( const sal_Unicode* pPossibleNumericData )
442 {
443 DATASET eRet = D_SYNT_ERROR;
444 if( bPlain )
445 {
446 if( ScanFloatVal( pPossibleNumericData ) )
447 eRet = D_NUMERIC;
448 else
449 eRet = D_SYNT_ERROR;
450 }
451 else
452 { // ...und zur Strafe mit'm Numberformatter...
453 DBG_ASSERT( pNumFormatter, "-DifParser::GetNextDataset(): No Formatter, more fun!" );
454 String aTestVal( pPossibleNumericData );
455 sal_uInt32 nFormat = 0;
456 double fTmpVal;
457 if( pNumFormatter->IsNumberFormat( aTestVal, nFormat, fTmpVal ) )
458 {
459 fVal = fTmpVal;
460 nNumFormat = nFormat;
461 eRet = D_NUMERIC;
462 }
463 else
464 eRet = D_SYNT_ERROR;
465 }
466 return eRet;
467 }
468
469 bool DifParser::ReadNextLine( String& rStr )
470 {
471 if( aLookAheadLine.Len() == 0 )
472 {
473 return rIn.ReadUniOrByteStringLine( rStr );
474 }
475 else
476 {
477 rStr = aLookAheadLine;
478 aLookAheadLine.Erase();
479 return true;
480 }
481 }
482
483 // Look ahead in the stream to determine if the next line is the first line of
484 // a valid data record structure
485 bool DifParser::LookAhead()
486 {
487 const sal_Unicode* pAktBuffer;
488 bool bValidStructure = false;
489
490 DBG_ASSERT( aLookAheadLine.Len() == 0, "*DifParser::LookAhead(): LookAhead called twice in a row" );
491 rIn.ReadUniOrByteStringLine( aLookAheadLine );
492
493 pAktBuffer = aLookAheadLine.GetBuffer();
494
495 switch( *pAktBuffer )
496 {
497 case '-': // Special Datatype
498 pAktBuffer++;
499
500 if( Is1_0( pAktBuffer ) )
501 {
502 bValidStructure = true;
503 }
504 break;
505 case '0': // Numeric Data
506 pAktBuffer++;
507 if( *pAktBuffer == ',' )
508 {
509 pAktBuffer++;
510 bValidStructure = ( GetNumberDataset(pAktBuffer) != D_SYNT_ERROR );
511 }
512 break;
513 case '1': // String Data
514 if( Is1_0( aLookAheadLine.GetBuffer() ) )
515 {
516 bValidStructure = true;
517 }
518 break;
519 }
520 return bValidStructure;
521 }
522
523 DATASET DifParser::GetNextDataset( void )
524 {
525 DATASET eRet = D_UNKNOWN;
526 String aLine;
527 const sal_Unicode* pAktBuffer;
528
529 ReadNextLine( aLine );
530
531 pAktBuffer = aLine.GetBuffer();
532
533 switch( *pAktBuffer )
534 {
535 case '-': // Special Datatype
536 pAktBuffer++;
537
538 if( Is1_0( pAktBuffer ) )
539 {
540 ReadNextLine( aLine );
541 if( IsBOT( aLine.GetBuffer() ) )
542 eRet = D_BOT;
543 else if( IsEOD( aLine.GetBuffer() ) )
544 eRet = D_EOD;
545 }
546 break;
547 case '0': // Numeric Data
548 pAktBuffer++; // Wert in fVal, 2. Zeile in aData
549 if( *pAktBuffer == ',' )
550 {
551 pAktBuffer++;
552 eRet = GetNumberDataset(pAktBuffer);
553 ReadNextLine( aData );
554 if ( eRet == D_SYNT_ERROR )
555 { // for broken records write "#ERR: data" to cell
556 String aTmp( RTL_CONSTASCII_USTRINGPARAM( "#ERR: " ));
557 aTmp += pAktBuffer;
558 aTmp.AppendAscii( " (" );
559 aTmp += aData;
560 aTmp += sal_Unicode(')');
561 aData = aTmp;
562 eRet = D_STRING;
563 }
564 }
565 break;
566 case '1': // String Data
567 if( Is1_0( aLine.GetBuffer() ) )
568 {
569 ReadNextLine( aLine );
570 xub_StrLen nLineLength = aLine.Len();
571 const sal_Unicode* pLine = aLine.GetBuffer();
572
573 if( nLineLength >= 1 && *pLine == '"' )
574 {
575 // Quotes are not always escaped (duplicated), see lcl_DeEscapeQuotesDif
576 // A look ahead into the next line is needed in order to deal with
577 // multiline strings containing quotes
578 if( LookAhead() )
579 {
580 // Single line string
581 if( nLineLength >= 2 && pLine[nLineLength - 1] == '"' )
582 {
583 aData = aLine.Copy( 1, nLineLength - 2 );
584 lcl_DeEscapeQuotesDif( aData );
585 eRet = D_STRING;
586 }
587 }
588 else
589 {
590 // Multiline string
591 aData = aLine.Copy( 1 );
592 bool bContinue = true;
593 while ( bContinue )
594 {
595 aData.Append( '\n' );
596 bContinue = !rIn.IsEof() && ReadNextLine( aLine );
597 if( bContinue )
598 {
599 nLineLength = aLine.Len();
600 if( nLineLength >= 1 )
601 {
602 pLine = aLine.GetBuffer();
603 bContinue = !LookAhead();
604 if( bContinue )
605 {
606 aData.Append( aLine );
607 }
608 else if( pLine[nLineLength - 1] == '"' )
609 {
610 aData.Append( pLine, nLineLength - 1 );
611 lcl_DeEscapeQuotesDif( aData );
612 eRet = D_STRING;
613 }
614 }
615 }
616 };
617 }
618 }
619 }
620 break;
621 }
622
623 if( eRet == D_UNKNOWN )
624 ReadNextLine( aLine );
625
626 if( rIn.IsEof() )
627 eRet = D_EOD;
628
629 return eRet;
630 }
631
632
633 const sal_Unicode* DifParser::ScanIntVal( const sal_Unicode* pStart, UINT32& rRet )
634 {
635 // eat leading whitespace, not specified, but seen in the wild
636 while (*pStart == ' ' || *pStart == '\t')
637 ++pStart;
638
639 sal_Unicode cAkt = *pStart;
640
641 if( IsNumber( cAkt ) )
642 rRet = ( UINT32 ) ( cAkt - '0' );
643 else
644 return NULL;
645
646 pStart++;
647 cAkt = *pStart;
648
649 while( IsNumber( cAkt ) && rRet < ( 0xFFFFFFFF / 10 ) )
650 {
651 rRet *= 10;
652 rRet += ( UINT32 ) ( cAkt - '0' );
653
654 pStart++;
655 cAkt = *pStart;
656 }
657
658 return pStart;
659 }
660
661
662 BOOL DifParser::ScanFloatVal( const sal_Unicode* pStart )
663 {
664 double fNewVal = 0.0;
665 BOOL bNeg = FALSE;
666 double fFracPos = 1.0;
667 INT32 nExp = 0;
668 BOOL bExpNeg = FALSE;
669 BOOL bExpOverflow = FALSE;
670 static const UINT16 nExpLimit = 4096; // ACHTUNG: muss genauer ermittelt werden!
671
672 sal_Unicode cAkt;
673 BOOL bRet = FALSE;
674
675 enum STATE { S_FIRST, S_PRE, S_POST, S_EXP_FIRST, S_EXP, S_END, S_FINDEND };
676
677 STATE eS = S_FIRST;
678
679 fNewVal = 0.0;
680
681 while( eS != S_END )
682 {
683 cAkt = *pStart;
684 switch( eS )
685 {
686 case S_FIRST:
687 if( IsNumber( cAkt ) )
688 {
689 fNewVal *= 10;
690 fNewVal += cAkt - '0';
691 eS = S_PRE;
692 }
693 else
694 {
695 switch( cAkt )
696 {
697 case ' ':
698 case '\t':
699 case '+':
700 break;
701 case '-':
702 bNeg = !bNeg;
703 break;
704 case '.':
705 case ',': //!
706 eS = S_POST;
707 fFracPos = 0.1;
708 break;
709 default:
710 eS = S_END;
711 }
712 }
713 break;
714 case S_PRE:
715 if( IsNumber( cAkt ) )
716 {
717 fNewVal *= 10;
718 fNewVal += cAkt - '0';
719 }
720 else
721 {
722 switch( cAkt )
723 {
724 case '.':
725 case ',': //!
726 eS = S_POST;
727 fFracPos = 0.1;
728 break;
729 case 'e':
730 case 'E':
731 eS = S_EXP;
732 break;
733 case 0x00: // IsNumberEnding( cAkt )
734 bRet = TRUE; // no
735 default: // break!
736 eS = S_END;
737 }
738 }
739 break;
740 case S_POST:
741 if( IsNumber( cAkt ) )
742 {
743 fNewVal += fFracPos * ( cAkt - '0' );
744 fFracPos /= 10.0;
745 }
746 else
747 {
748 switch( cAkt )
749 {
750 case 'e':
751 case 'E':
752 eS = S_EXP_FIRST;
753 break;
754 case 0x00: // IsNumberEnding( cAkt )
755 bRet = TRUE; // no
756 default: // break!
757 eS = S_END;
758 }
759 }
760 break;
761 case S_EXP_FIRST:
762 if( IsNumber( cAkt ) )
763 {
764 if( nExp < nExpLimit )
765 {
766 nExp *= 10;
767 nExp += ( UINT16 ) ( cAkt - '0' );
768 }
769 eS = S_EXP;
770 }
771 else
772 {
773 switch( cAkt )
774 {
775 case '+':
776 break;
777 case '-':
778 bExpNeg = !bExpNeg;
779 break;
780 default:
781 eS = S_END;
782 }
783 }
784 break;
785 case S_EXP:
786 if( IsNumber( cAkt ) )
787 {
788 if( nExp < ( 0xFFFF / 10 ) )
789 {
790 nExp *= 10;
791 nExp += ( UINT16 ) ( cAkt - '0' );
792 }
793 else
794 {
795 bExpOverflow = TRUE;
796 eS = S_FINDEND;
797 }
798 }
799 else
800 {
801 bRet = IsNumberEnding( cAkt );
802 eS = S_END;
803 }
804 break;
805 case S_FINDEND:
806 if( IsNumberEnding( cAkt ) )
807 {
808 bRet = TRUE; // damit sinnvoll weitergeparst werden kann
809 eS = S_END;
810 }
811 break;
812 case S_END:
813 DBG_ERRORFILE( "DifParser::ScanFloatVal - unexpected state" );
814 break;
815 default:
816 DBG_ERRORFILE( "DifParser::ScanFloatVal - missing enum" );
817 }
818 pStart++;
819 }
820
821 if( bRet )
822 {
823 if( bExpOverflow )
824 return sal_False; // ACHTUNG: hier muss noch differenziert werden
825
826 if( bNeg )
827 fNewVal *= 1.0;
828
829 if( bExpNeg )
830 nExp *= -1;
831
832 if( nExp != 0 )
833 fNewVal *= pow( 10.0, ( double ) nExp );
834 fVal = fNewVal;
835 }
836
837 return bRet;
838 }
839
840
841 DifColumn::~DifColumn( void )
842 {
843 ENTRY* pEntry = ( ENTRY* ) List::First();
844
845 while( pEntry )
846 {
847 delete pEntry;
848 pEntry = ( ENTRY* ) List::Next();
849 }
850 }
851
852
853 void DifColumn::SetLogical( SCROW nRow )
854 {
855 DBG_ASSERT( ValidRow(nRow), "*DifColumn::SetLogical(): Row zu gross!" );
856
857 if( pAkt )
858 {
859 DBG_ASSERT( nRow > 0, "*DifColumn::SetLogical(): weitere koennen nicht 0 sein!" );
860 nRow--;
861 if( pAkt->nEnd == nRow )
862 pAkt->nEnd++;
863 else
864 pAkt = NULL;
865 }
866 else
867 {
868 pAkt = new ENTRY;
869 pAkt->nStart = pAkt->nEnd = nRow;
870 List::Insert( pAkt, LIST_APPEND );
871 }
872 }
873
874
875 void DifColumn::SetNumFormat( SCROW nRow, const UINT32 nNumFormat )
876 {
877 DBG_ASSERT( ValidRow(nRow), "*DifColumn::SetNumFormat(): Row zu gross!" );
878
879 if( nNumFormat > 0 )
880 {
881 if( pAkt )
882 {
883 DBG_ASSERT( nRow > 0,
884 "*DifColumn::SetNumFormat(): weitere koennen nicht 0 sein!" );
885 DBG_ASSERT( nRow > pAkt->nEnd,
886 "*DifColumn::SetNumFormat(): Noch 'mal von vorne?" );
887
888 if( pAkt->nNumFormat == nNumFormat && pAkt->nEnd == nRow - 1 )
889 pAkt->nEnd = nRow;
890 else
891 NewEntry( nRow, nNumFormat );
892 }
893 else
894 NewEntry( nRow, nNumFormat );
895 }
896 else
897 pAkt = NULL;
898 }
899
900
901 void DifColumn::NewEntry( const SCROW nPos, const UINT32 nNumFormat )
902 {
903 pAkt = new ENTRY;
904 pAkt->nStart = pAkt->nEnd = nPos;
905 pAkt->nNumFormat = nNumFormat;
906 List::Insert( pAkt, LIST_APPEND );
907 }
908
909
910 void DifColumn::Apply( ScDocument& rDoc, const SCCOL nCol, const SCTAB nTab, const ScPatternAttr& rPattAttr )
911 {
912 ENTRY* pEntry = ( ENTRY* ) List::First();
913
914 while( pEntry )
915 {
916 rDoc.ApplyPatternAreaTab( nCol, pEntry->nStart, nCol, pEntry->nEnd,
917 nTab, rPattAttr );
918 pEntry = ( ENTRY* ) List::Next();
919 }
920 }
921
922
923 void DifColumn::Apply( ScDocument& rDoc, const SCCOL nCol, const SCTAB nTab )
924 {
925 ScPatternAttr aAttr( rDoc.GetPool() );
926 SfxItemSet& rItemSet = aAttr.GetItemSet();
927
928 ENTRY* pEntry = ( ENTRY* ) List::First();
929
930 while( pEntry )
931 {
932 DBG_ASSERT( pEntry->nNumFormat > 0,
933 "+DifColumn::Apply(): Numberformat darf hier nicht 0 sein!" );
934 rItemSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, pEntry->nNumFormat ) );
935
936 rDoc.ApplyPatternAreaTab( nCol, pEntry->nStart, nCol, pEntry->nEnd, nTab, aAttr );
937
938 rItemSet.ClearItem();
939
940 pEntry = ( ENTRY* ) List::Next();
941 }
942 }
943
944
945 DifAttrCache::DifAttrCache( const BOOL bNewPlain )
946 {
947 bPlain = bNewPlain;
948 ppCols = new DifColumn *[ MAXCOL + 1 ];
949 for( SCCOL nCnt = 0 ; nCnt <= MAXCOL ; nCnt++ )
950 ppCols[ nCnt ] = NULL;
951 }
952
953
954 DifAttrCache::~DifAttrCache()
955 {
956 for( SCCOL nCnt = 0 ; nCnt <= MAXCOL ; nCnt++ )
957 {
958 if( ppCols[ nCnt ] )
959 delete ppCols[ nCnt ];
960 }
961 }
962
963
964 void DifAttrCache::SetNumFormat( const SCCOL nCol, const SCROW nRow, const UINT32 nNumFormat )
965 {
966 DBG_ASSERT( ValidCol(nCol), "-DifAttrCache::SetNumFormat(): Col zu gross!" );
967 DBG_ASSERT( !bPlain, "*DifAttrCache::SetNumFormat(): sollte nicht Plain sein!" );
968
969 if( !ppCols[ nCol ] )
970 ppCols[ nCol ] = new DifColumn;
971
972 ppCols[ nCol ]->SetNumFormat( nRow, nNumFormat );
973 }
974
975
976 void DifAttrCache::Apply( ScDocument& rDoc, SCTAB nTab )
977 {
978 if( bPlain )
979 {
980 ScPatternAttr* pPatt = NULL;
981
982 for( SCCOL nCol = 0 ; nCol <= MAXCOL ; nCol++ )
983 {
984 if( ppCols[ nCol ] )
985 {
986 if( !pPatt )
987 {
988 pPatt = new ScPatternAttr( rDoc.GetPool() );
989 pPatt->GetItemSet().Put( SfxUInt32Item( ATTR_VALUE_FORMAT,
990 rDoc.GetFormatTable()->GetStandardFormat( NUMBERFORMAT_LOGICAL ) ) );
991 }
992
993 ppCols[ nCol ]->Apply( rDoc, nCol, nTab, *pPatt );
994 }
995 }
996
997 if( pPatt )
998 delete pPatt;
999 }
1000 else
1001 {
1002 for( SCCOL nCol = 0 ; nCol <= MAXCOL ; nCol++ )
1003 {
1004 if( ppCols[ nCol ] )
1005 ppCols[ nCol ]->Apply( rDoc, nCol, nTab );
1006 }
1007 }
1008 }
1009
1010
1011
vba interoperability for OOo