Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "excform.hxx"
21 : #include <osl/endian.h>
22 :
23 : #include "formulacell.hxx"
24 : #include "document.hxx"
25 : #include "rangenam.hxx"
26 : #include "global.hxx"
27 : #include "scmatrix.hxx"
28 :
29 : #include <formula/errorcodes.hxx>
30 : #include <svl/sharedstringpool.hxx>
31 :
32 : #include "imp_op.hxx"
33 : #include "root.hxx"
34 : #include "xltracer.hxx"
35 : #include "xihelper.hxx"
36 : #include "xilink.hxx"
37 : #include "xiname.hxx"
38 : #include "documentimport.hxx"
39 :
40 : using ::std::vector;
41 :
42 : const sal_uInt16 ExcelToSc::nRowMask = 0x3FFF;
43 : const sal_uInt16 ExcelToSc::nLastInd = 399;
44 :
45 7094 : void ImportExcel::Formula25()
46 : {
47 7094 : XclAddress aXclPos;
48 7094 : sal_uInt16 nXF = 0, nFormLen;
49 : double fCurVal;
50 : sal_uInt8 nFlag0;
51 : bool bShrFmla;
52 :
53 7094 : aIn >> aXclPos;
54 :
55 7094 : if( GetBiff() == EXC_BIFF2 )
56 : {// BIFF2
57 : sal_uInt8 nDummy;
58 :
59 0 : aIn.Ignore( 3 );
60 :
61 0 : aIn >> fCurVal;
62 0 : aIn.Ignore( 1 );
63 0 : aIn >> nDummy;
64 0 : nFormLen = nDummy;
65 0 : bShrFmla = false;
66 : }
67 : else
68 : {// BIFF5
69 7094 : aIn >> nXF >> fCurVal >> nFlag0;
70 7094 : aIn.Ignore( 5 );
71 :
72 7094 : aIn >> nFormLen;
73 :
74 7094 : bShrFmla = nFlag0 & 0x08; // shared or not shared
75 : }
76 :
77 7094 : Formula( aXclPos, nXF, nFormLen, fCurVal, bShrFmla );
78 7094 : }
79 :
80 0 : void ImportExcel::Formula3()
81 : {
82 0 : Formula4();
83 0 : }
84 :
85 0 : void ImportExcel::Formula4()
86 : {
87 0 : XclAddress aXclPos;
88 : sal_uInt16 nXF, nFormLen;
89 : double fCurVal;
90 : sal_uInt8 nFlag0;
91 :
92 0 : aIn >> aXclPos >> nXF >> fCurVal >> nFlag0;
93 0 : aIn.Ignore( 1 );
94 0 : aIn >> nFormLen;
95 :
96 0 : Formula( aXclPos, nXF, nFormLen, fCurVal, false );
97 0 : }
98 :
99 7094 : void ImportExcel::Formula(
100 : const XclAddress& rXclPos, sal_uInt16 nXF, sal_uInt16 nFormLen, double fCurVal, bool bShrFmla)
101 : {
102 7094 : if (!nFormLen)
103 1772 : return;
104 :
105 7094 : ScAddress aScPos( ScAddress::UNINITIALIZED );
106 7094 : if (!GetAddressConverter().ConvertAddress(aScPos, rXclPos, GetCurrScTab(), true))
107 : // Conversion failed.
108 0 : return;
109 :
110 : // Formula will be read next, length in nFormLen
111 7094 : const ScTokenArray* pResult = NULL;
112 :
113 7094 : pFormConv->Reset( aScPos );
114 7094 : ScDocumentImport& rDoc = GetDocImport();
115 :
116 7094 : if (bShrFmla)
117 : {
118 : // This is a shared formula. Get the token array from the shared formula pool.
119 : SCCOL nSharedCol;
120 : SCROW nSharedRow;
121 2268 : if (pFormConv->ReadSharedFormulaPosition(maStrm, nSharedCol, nSharedRow))
122 : {
123 1772 : ScAddress aRefPos(nSharedCol, nSharedRow, GetCurrScTab());
124 1772 : const ScTokenArray* pSharedCode = pFormConv->GetSharedFormula(aRefPos);
125 1772 : if (pSharedCode)
126 : {
127 1542 : ScFormulaCell* pCell = new ScFormulaCell(pD, aScPos, pSharedCode->Clone());
128 1542 : pCell->GetCode()->WrapReference(aScPos, EXC_MAXCOL8, EXC_MAXROW8);
129 1542 : rDoc.getDoc().EnsureTable(aScPos.Tab());
130 1542 : rDoc.setFormulaCell(aScPos, pCell);
131 1542 : pCell->SetNeedNumberFormat(false);
132 1542 : if (!rtl::math::isNan(fCurVal))
133 1508 : pCell->SetResultDouble(fCurVal);
134 :
135 1542 : GetXFRangeBuffer().SetXF(aScPos, nXF);
136 1542 : SetLastFormula(aScPos.Col(), aScPos.Row(), fCurVal, nXF, pCell);
137 : }
138 : else
139 : {
140 : // Shared formula not found even though it's clearly a shared formula.
141 : // The cell will be created in the following shared formula
142 : // record.
143 230 : SetLastFormula(aScPos.Col(), aScPos.Row(), fCurVal, nXF, NULL);
144 : }
145 1772 : return;
146 : }
147 : }
148 :
149 5322 : ConvErr eErr = pFormConv->Convert( pResult, maStrm, nFormLen, true, FT_CellFormula);
150 :
151 5322 : ScFormulaCell* pCell = NULL;
152 :
153 5322 : if (pResult)
154 : {
155 5208 : pCell = new ScFormulaCell(&rDoc.getDoc(), aScPos, *pResult);
156 5208 : pCell->GetCode()->WrapReference(aScPos, EXC_MAXCOL8, EXC_MAXROW8);
157 5208 : rDoc.getDoc().EnsureTable(aScPos.Tab());
158 5208 : rDoc.setFormulaCell(aScPos, pCell);
159 5208 : SetLastFormula(aScPos.Col(), aScPos.Row(), fCurVal, nXF, pCell);
160 : }
161 : else
162 : {
163 114 : pCell = rDoc.getDoc().GetFormulaCell(aScPos);
164 114 : if (pCell)
165 110 : pCell->AddRecalcMode( RECALCMODE_ONLOAD_ONCE );
166 : }
167 :
168 5322 : if (pCell)
169 : {
170 5318 : pCell->SetNeedNumberFormat(false);
171 5318 : if( eErr != ConvOK )
172 2 : ExcelToSc::SetError( *pCell, eErr );
173 :
174 5318 : if (!rtl::math::isNan(fCurVal))
175 5306 : pCell->SetResultDouble(fCurVal);
176 : }
177 :
178 5322 : GetXFRangeBuffer().SetXF(aScPos, nXF);
179 : }
180 :
181 290 : ExcelToSc::ExcelToSc( XclImpRoot& rRoot ) :
182 290 : ExcelConverterBase(rRoot.GetDocImport().getDoc().GetSharedStringPool(), 512),
183 : XclImpRoot( rRoot ),
184 : bExternName( false ),
185 : maFuncProv( rRoot ),
186 290 : meBiff( rRoot.GetBiff() )
187 : {
188 290 : }
189 :
190 434 : ExcelToSc::~ExcelToSc()
191 : {
192 434 : }
193 :
194 0 : void ExcelToSc::GetDummy( const ScTokenArray*& pErgebnis )
195 : {
196 0 : aPool.Store( OUString("Dummy()") );
197 0 : aPool >> aStack;
198 0 : pErgebnis = aPool[ aStack.Get() ];
199 0 : }
200 :
201 : // if bAllowArrays is false stream seeks to first byte after <nFormulaLen>
202 : // otherwise it will seek to the first byte after the additional content (eg
203 : // inline arrays) following <nFormulaLen>
204 90 : ConvErr ExcelToSc::Convert( const ScTokenArray*& pErgebnis, XclImpStream& aIn, sal_Size nFormulaLen, bool bAllowArrays, const FORMULA_TYPE eFT )
205 : {
206 90 : RootData& rR = GetOldRoot();
207 : sal_uInt8 nOp, nLen, nByte;
208 : sal_uInt16 nUINT16;
209 : sal_Int16 nINT16;
210 : double fDouble;
211 90 : OUString aString;
212 90 : bool bError = false;
213 90 : bool bArrayFormula = false;
214 90 : TokenId nMerk0;
215 90 : const bool bRangeName = eFT == FT_RangeName;
216 90 : const bool bSharedFormula = eFT == FT_SharedFormula;
217 90 : const bool bConditional = eFT == FT_CondFormat;
218 90 : const bool bRNorSF = bRangeName || bSharedFormula || bConditional;
219 :
220 : ScSingleRefData aSRD;
221 : ScComplexRefData aCRD;
222 180 : ExtensionTypeVec aExtensions;
223 :
224 90 : bExternName = false;
225 :
226 90 : if( eStatus != ConvOK )
227 : {
228 0 : aIn.Ignore( nFormulaLen );
229 0 : return eStatus;
230 : }
231 :
232 90 : if( nFormulaLen == 0 )
233 : {
234 0 : aPool.Store( OUString("-/-") );
235 0 : aPool >> aStack;
236 0 : pErgebnis = aPool[ aStack.Get() ];
237 0 : return ConvOK;
238 : }
239 :
240 90 : sal_Size nEndPos = aIn.GetRecPos() + nFormulaLen;
241 :
242 442 : while( (aIn.GetRecPos() < nEndPos) && !bError )
243 : {
244 262 : aIn >> nOp;
245 :
246 : // always reset flags
247 262 : aSRD.InitFlags();
248 262 : aCRD.InitFlags();
249 :
250 262 : switch( nOp ) // book page:
251 : { // SDK4 SDK5
252 : case 0x01: // Array Formula [325 ]
253 : // Array Formula or Shared Formula [ 277]
254 : case 0x02: // Data Table [325 277]
255 0 : nUINT16 = 3;
256 :
257 0 : if( meBiff != EXC_BIFF2 )
258 0 : nUINT16++;
259 :
260 0 : aIn.Ignore( nUINT16 );
261 :
262 0 : bArrayFormula = true;
263 0 : break;
264 : case 0x03: // Addition [312 264]
265 84 : aStack >> nMerk0;
266 84 : aPool << aStack << ocAdd << nMerk0;
267 84 : aPool >> aStack;
268 84 : break;
269 : case 0x04: // Subtraction [313 264]
270 : // SECOND-TOP minus TOP
271 0 : aStack >> nMerk0;
272 0 : aPool << aStack << ocSub << nMerk0;
273 0 : aPool >> aStack;
274 0 : break;
275 : case 0x05: // Multiplication [313 264]
276 0 : aStack >> nMerk0;
277 0 : aPool << aStack << ocMul << nMerk0;
278 0 : aPool >> aStack;
279 0 : break;
280 : case 0x06: // Division [313 264]
281 : // divide TOP by SECOND-TOP
282 0 : aStack >> nMerk0;
283 0 : aPool << aStack << ocDiv << nMerk0;
284 0 : aPool >> aStack;
285 0 : break;
286 : case 0x07: // Exponentiation [313 265]
287 : // raise SECOND-TOP to power of TOP
288 0 : aStack >> nMerk0;
289 0 : aPool << aStack << ocPow << nMerk0;
290 0 : aPool >> aStack;
291 0 : break;
292 : case 0x08: // Concatenation [313 265]
293 : // append TOP to SECOND-TOP
294 0 : aStack >> nMerk0;
295 0 : aPool << aStack << ocAmpersand << nMerk0;
296 0 : aPool >> aStack;
297 0 : break;
298 : case 0x09: // Less Than [313 265]
299 : // SECOND-TOP < TOP
300 0 : aStack >> nMerk0;
301 0 : aPool << aStack << ocLess << nMerk0;
302 0 : aPool >> aStack;
303 0 : break;
304 : case 0x0A: // Less Than or Equal [313 265]
305 : // SECOND-TOP <= TOP
306 0 : aStack >> nMerk0;
307 0 : aPool << aStack << ocLessEqual << nMerk0;
308 0 : aPool >> aStack;
309 0 : break;
310 : case 0x0B: // Equal [313 265]
311 : // SECOND-TOP == TOP
312 0 : aStack >> nMerk0;
313 0 : aPool << aStack << ocEqual << nMerk0;
314 0 : aPool >> aStack;
315 0 : break;
316 : case 0x0C: // Greater Than or Equal [313 265]
317 : // SECOND-TOP >= TOP
318 0 : aStack >> nMerk0;
319 0 : aPool << aStack << ocGreaterEqual << nMerk0;
320 0 : aPool >> aStack;
321 0 : break;
322 : case 0x0D: // Greater Than [313 265]
323 : // SECOND-TOP > TOP
324 0 : aStack >> nMerk0;
325 0 : aPool << aStack << ocGreater << nMerk0;
326 0 : aPool >> aStack;
327 0 : break;
328 : case 0x0E: // Not Equal [313 265]
329 : // SECOND-TOP != TOP
330 0 : aStack >> nMerk0;
331 0 : aPool << aStack << ocNotEqual << nMerk0;
332 0 : aPool >> aStack;
333 0 : break;
334 : case 0x0F: // Intersection [314 265]
335 0 : aStack >> nMerk0;
336 0 : aPool << aStack << ocIntersect << nMerk0;
337 0 : aPool >> aStack;
338 0 : break;
339 : case 0x10: // Union [314 265]
340 : // ocSep instead of 'ocUnion'
341 0 : aStack >> nMerk0;
342 0 : aPool << aStack << ocSep << nMerk0;
343 : // doesn't fit exactly, but is more Excel-like
344 0 : aPool >> aStack;
345 0 : break;
346 : case 0x11: // Range [314 265]
347 0 : aStack >> nMerk0;
348 0 : aPool << aStack << ocRange << nMerk0;
349 0 : aPool >> aStack;
350 0 : break;
351 : case 0x12: // Unary Plus [312 264]
352 0 : aPool << ocAdd << aStack;
353 0 : aPool >> aStack;
354 0 : break;
355 : case 0x13: // Unary Minus [312 264]
356 0 : aPool << ocNegSub << aStack;
357 0 : aPool >> aStack;
358 0 : break;
359 : case 0x14: // Percent Sign [312 264]
360 0 : aPool << aStack << ocPercentSign;
361 0 : aPool >> aStack;
362 0 : break;
363 : case 0x15: // Parenthesis [326 278]
364 0 : aPool << ocOpen << aStack << ocClose;
365 0 : aPool >> aStack;
366 0 : break;
367 : case 0x16: // Missing Argument [314 266]
368 0 : aPool << ocMissing;
369 0 : aPool >> aStack;
370 0 : GetTracer().TraceFormulaMissingArg();
371 0 : break;
372 : case 0x17: // String Constant [314 266]
373 0 : aIn >> nLen;
374 0 : aString = aIn.ReadRawByteString( nLen );
375 :
376 0 : aStack << aPool.Store( aString );
377 0 : break;
378 : case 0x19: // Special Attribute [327 279]
379 : {
380 4 : sal_uInt16 nData(0), nFakt(0);
381 4 : sal_uInt8 nOpt(0);
382 :
383 4 : aIn >> nOpt;
384 :
385 4 : if( meBiff == EXC_BIFF2 )
386 : {
387 0 : nData = aIn.ReaduInt8();
388 0 : nFakt = 1;
389 : }
390 : else
391 : {
392 4 : aIn >> nData;
393 4 : nFakt = 2;
394 : }
395 :
396 4 : if( nOpt & 0x04 )
397 : {
398 : // nFakt -> skip bytes or words AttrChoose
399 0 : ++nData;
400 0 : aIn.Ignore(static_cast<sal_Size>(nData) * nFakt);
401 : }
402 4 : else if( nOpt & 0x10 ) // AttrSum
403 4 : DoMulArgs( ocSum, 1 );
404 : }
405 4 : break;
406 : case 0x1A: // External Reference [330 ]
407 0 : switch( meBiff )
408 : {
409 0 : case EXC_BIFF2: aIn.Ignore( 7 ); break;
410 : case EXC_BIFF3:
411 0 : case EXC_BIFF4: aIn.Ignore( 10 ); break;
412 : case EXC_BIFF5:
413 : DBG_WARNING( "-ExcelToSc::Convert(): 0x1A does not exist in Biff5!" );
414 : //fall-through
415 : default:
416 : DBG_WARNING( "-ExcelToSc::Convert(): A little oblivious?" );
417 : }
418 0 : break;
419 : case 0x1B: // End External Reference [330 ]
420 0 : switch( meBiff )
421 : {
422 0 : case EXC_BIFF2: aIn.Ignore( 3 ); break;
423 : case EXC_BIFF3:
424 0 : case EXC_BIFF4: aIn.Ignore( 4 ); break;
425 : case EXC_BIFF5:
426 : DBG_WARNING( "-ExcelToSc::Convert(): 0x1B does not exist in Biff5!" );
427 : //fall-through
428 : default:
429 : DBG_WARNING( "-ExcelToSc::Convert(): A little oblivious?" );
430 : }
431 0 : break;
432 : case 0x1C: // Error Value [314 266]
433 : {
434 0 : aIn >> nByte;
435 : DefTokenId eOc;
436 0 : switch( nByte )
437 : {
438 : case EXC_ERR_NULL:
439 : case EXC_ERR_DIV0:
440 : case EXC_ERR_VALUE:
441 : case EXC_ERR_REF:
442 : case EXC_ERR_NAME:
443 0 : case EXC_ERR_NUM: eOc = ocStop; break;
444 0 : case EXC_ERR_NA: eOc = ocNotAvail; break;
445 0 : default: eOc = ocNoName;
446 : }
447 0 : aPool << eOc;
448 0 : if( eOc != ocStop )
449 0 : aPool << ocOpen << ocClose;
450 0 : aPool >> aStack;
451 : }
452 0 : break;
453 : case 0x1D: // Boolean [315 266]
454 0 : aIn >> nByte;
455 0 : if( nByte == 0 )
456 0 : aPool << ocFalse << ocOpen << ocClose;
457 : else
458 0 : aPool << ocTrue << ocOpen << ocClose;
459 0 : aPool >> aStack;
460 0 : break;
461 : case 0x1E: // Integer [315 266]
462 0 : aIn >> nUINT16;
463 0 : aStack << aPool.Store( ( double ) nUINT16 );
464 0 : break;
465 : case 0x1F: // Number [315 266]
466 0 : aIn >> fDouble;
467 0 : aStack << aPool.Store( fDouble );
468 0 : break;
469 : case 0x40:
470 : case 0x60:
471 : case 0x20: // Array Constant [317 268]
472 0 : aIn >> nByte >> nUINT16;
473 0 : aIn.Ignore( (meBiff == EXC_BIFF2) ? 3 : 4 );
474 0 : if( bAllowArrays )
475 : {
476 0 : aStack << aPool.StoreMatrix();
477 0 : aExtensions.push_back( EXTENSION_ARRAY );
478 : }
479 : else
480 : {
481 0 : aPool << ocBad;
482 0 : aPool >> aStack;
483 : }
484 0 : break;
485 : case 0x41:
486 : case 0x61:
487 : case 0x21: // Function, Fixed Number of Arguments [333 282]
488 : {
489 : sal_uInt16 nXclFunc;
490 0 : if( meBiff <= EXC_BIFF3 )
491 0 : nXclFunc = aIn.ReaduInt8();
492 : else
493 0 : aIn >> nXclFunc;
494 0 : if( const XclFunctionInfo* pFuncInfo = maFuncProv.GetFuncInfoFromXclFunc( nXclFunc ) )
495 0 : DoMulArgs( pFuncInfo->meOpCode, pFuncInfo->mnMaxParamCount );
496 : else
497 0 : DoMulArgs( ocNoName, 0 );
498 : }
499 0 : break;
500 : case 0x42:
501 : case 0x62:
502 : case 0x22: // Function, Variable Number of Arg. [333 283]
503 : {
504 : sal_uInt16 nXclFunc;
505 : sal_uInt8 nParamCount;
506 0 : aIn >> nParamCount;
507 0 : nParamCount &= 0x7F;
508 0 : if( meBiff <= EXC_BIFF3 )
509 0 : nXclFunc = aIn.ReaduInt8();
510 : else
511 0 : aIn >> nXclFunc;
512 0 : if( const XclFunctionInfo* pFuncInfo = maFuncProv.GetFuncInfoFromXclFunc( nXclFunc ) )
513 0 : DoMulArgs( pFuncInfo->meOpCode, nParamCount );
514 : else
515 0 : DoMulArgs( ocNoName, 0 );
516 : }
517 0 : break;
518 : case 0x43:
519 : case 0x63:
520 : case 0x23: // Name [318 269]
521 : {
522 0 : aIn >> nUINT16;
523 0 : switch( meBiff )
524 : {
525 0 : case EXC_BIFF2: aIn.Ignore( 5 ); break;
526 : case EXC_BIFF3:
527 0 : case EXC_BIFF4: aIn.Ignore( 8 ); break;
528 0 : case EXC_BIFF5: aIn.Ignore( 12 ); break;
529 : default:
530 : OSL_FAIL(
531 : "-ExcelToSc::Convert(): A little oblivious?" );
532 : }
533 0 : const XclImpName* pName = GetNameManager().GetName( nUINT16 );
534 0 : if(pName && !pName->GetScRangeData())
535 0 : aStack << aPool.Store( ocMacro, pName->GetXclName() );
536 : else
537 0 : aStack << aPool.StoreName(nUINT16, true);
538 : }
539 0 : break;
540 : case 0x44:
541 : case 0x64:
542 : case 0x24: // Cell Reference [319 270]
543 : case 0x4A:
544 : case 0x6A:
545 : case 0x2A: // Deleted Cell Reference [323 273]
546 40 : aIn >> nUINT16 >> nByte;
547 40 : aSRD.SetAbsCol(static_cast<SCsCOL>(nByte));
548 40 : aSRD.SetAbsRow(nUINT16 & 0x3FFF);
549 40 : aSRD.SetRelTab(0);
550 40 : aSRD.SetFlag3D( bRangeName );
551 :
552 40 : ExcRelToScRel( nUINT16, nByte, aSRD, bRangeName );
553 :
554 40 : switch ( nOp )
555 : {
556 : case 0x4A:
557 : case 0x6A:
558 : case 0x2A: // Deleted Cell Reference [323 273]
559 : // no information which part is deleted, set both
560 0 : aSRD.SetColDeleted( true );
561 0 : aSRD.SetRowDeleted( true );
562 : }
563 :
564 40 : aStack << aPool.Store( aSRD );
565 40 : break;
566 : case 0x45:
567 : case 0x65:
568 : case 0x25: // Area Reference [320 270]
569 : case 0x4B:
570 : case 0x6B:
571 : case 0x2B: // Deleted Area Refernce [323 273]
572 : {
573 : sal_uInt16 nRowFirst, nRowLast;
574 : sal_uInt8 nColFirst, nColLast;
575 4 : ScSingleRefData& rSRef1 = aCRD.Ref1;
576 4 : ScSingleRefData& rSRef2 = aCRD.Ref2;
577 :
578 4 : aIn >> nRowFirst >> nRowLast >> nColFirst >> nColLast;
579 :
580 4 : rSRef1.SetRelTab(0);
581 4 : rSRef2.SetRelTab(0);
582 4 : rSRef1.SetFlag3D( bRangeName );
583 4 : rSRef2.SetFlag3D( bRangeName );
584 :
585 4 : ExcRelToScRel( nRowFirst, nColFirst, aCRD.Ref1, bRangeName );
586 4 : ExcRelToScRel( nRowLast, nColLast, aCRD.Ref2, bRangeName );
587 :
588 4 : if( IsComplColRange( nColFirst, nColLast ) )
589 0 : SetComplCol( aCRD );
590 4 : else if( IsComplRowRange( nRowFirst, nRowLast ) )
591 0 : SetComplRow( aCRD );
592 :
593 4 : switch ( nOp )
594 : {
595 : case 0x4B:
596 : case 0x6B:
597 : case 0x2B: // Deleted Area Refernce [323 273]
598 : // no information which part is deleted, set all
599 0 : rSRef1.SetColDeleted( true );
600 0 : rSRef1.SetRowDeleted( true );
601 0 : rSRef2.SetColDeleted( true );
602 0 : rSRef2.SetRowDeleted( true );
603 : }
604 :
605 4 : aStack << aPool.Store( aCRD );
606 : }
607 4 : break;
608 : case 0x46:
609 : case 0x66:
610 : case 0x26: // Constant Reference Subexpression [321 271]
611 0 : aExtensions.push_back( EXTENSION_MEMAREA );
612 : // fall through
613 :
614 : case 0x47:
615 : case 0x67:
616 : case 0x27: // Erroneous Constant Reference Subexpr. [322 272]
617 : case 0x48:
618 : case 0x68:
619 : case 0x28: // Incomplete Constant Reference Subexpr.[331 281]
620 0 : aIn.Ignore( (meBiff == EXC_BIFF2) ? 4 : 6 );
621 0 : break;
622 : case 0x4C:
623 : case 0x6C:
624 : case 0x2C: // Cell Reference Within a Name [323 ]
625 : // Cell Reference Within a Shared Formula[ 273]
626 : {
627 128 : aIn >> nUINT16 >> nByte; // >> Attribute, Row >> Col
628 :
629 128 : aSRD.SetRelTab(0);
630 128 : aSRD.SetFlag3D( bRangeName );
631 :
632 128 : ExcRelToScRel( nUINT16, nByte, aSRD, bRNorSF );
633 :
634 128 : aStack << aPool.Store( aSRD );
635 : }
636 128 : break;
637 : case 0x4D:
638 : case 0x6D:
639 : case 0x2D: // Area Reference Within a Name [324 ]
640 : { // Area Reference Within a Shared Formula[ 274]
641 : sal_uInt16 nRowFirst, nRowLast;
642 : sal_uInt8 nColFirst, nColLast;
643 :
644 0 : aCRD.Ref1.SetRelTab(0);
645 0 : aCRD.Ref2.SetRelTab(0);
646 0 : aCRD.Ref1.SetFlag3D( bRangeName );
647 0 : aCRD.Ref2.SetFlag3D( bRangeName );
648 :
649 0 : aIn >> nRowFirst >> nRowLast >> nColFirst >> nColLast;
650 :
651 0 : ExcRelToScRel( nRowFirst, nColFirst, aCRD.Ref1, bRNorSF );
652 0 : ExcRelToScRel( nRowLast, nColLast, aCRD.Ref2, bRNorSF );
653 :
654 0 : if( IsComplColRange( nColFirst, nColLast ) )
655 0 : SetComplCol( aCRD );
656 0 : else if( IsComplRowRange( nRowFirst, nRowLast ) )
657 0 : SetComplRow( aCRD );
658 :
659 0 : aStack << aPool.Store( aCRD );
660 : }
661 0 : break;
662 : case 0x49:
663 : case 0x69:
664 : case 0x29: // Variable Reference Subexpression [331 281]
665 : case 0x4E:
666 : case 0x6E:
667 : case 0x2E: // Reference Subexpression Within a Name [332 282]
668 : case 0x4F:
669 : case 0x6F:
670 : case 0x2F: // Incomplete Reference Subexpression... [332 282]
671 0 : aIn.Ignore( (meBiff == EXC_BIFF2) ? 1 : 2 );
672 0 : break;
673 : case 0x58:
674 : case 0x78:
675 : case 0x38: // Command-Equivalent Function [333 ]
676 0 : aString = "COMM_EQU_FUNC";
677 0 : aIn >> nByte;
678 0 : aString += OUString::number( nByte );
679 0 : aIn >> nByte;
680 0 : aStack << aPool.Store( aString );
681 0 : DoMulArgs( ocPush, nByte + 1 );
682 0 : break;
683 : case 0x59:
684 : case 0x79:
685 : case 0x39: // Name or External Name [ 275]
686 0 : aIn >> nINT16;
687 0 : aIn.Ignore( 8 );
688 0 : aIn >> nUINT16;
689 0 : if( nINT16 >= 0 )
690 : {
691 0 : const ExtName* pExtName = rR.pExtNameBuff->GetNameByIndex( nINT16, nUINT16 );
692 0 : if( pExtName && pExtName->IsDDE() &&
693 0 : rR.pExtSheetBuff->IsLink( ( sal_uInt16 ) nINT16 ) )
694 : {
695 0 : OUString aAppl, aExtDoc;
696 0 : TokenId nPar1, nPar2;
697 :
698 0 : rR.pExtSheetBuff->GetLink( ( sal_uInt16 ) nINT16 , aAppl, aExtDoc );
699 0 : nPar1 = aPool.Store( aAppl );
700 0 : nPar2 = aPool.Store( aExtDoc );
701 0 : nMerk0 = aPool.Store( pExtName->aName );
702 0 : aPool << ocDde << ocOpen << nPar1 << ocSep << nPar2 << ocSep
703 0 : << nMerk0 << ocClose;
704 :
705 0 : GetDoc().CreateDdeLink( aAppl, aExtDoc, pExtName->aName, SC_DDE_DEFAULT, ScMatrixRef() );
706 : }
707 : else
708 0 : aPool << ocBad;
709 :
710 0 : aPool >> aStack;
711 : }
712 : else
713 0 : aStack << aPool.StoreName( nUINT16, true );
714 0 : aIn.Ignore( 12 );
715 0 : break;
716 : case 0x5A:
717 : case 0x7A:
718 : case 0x3A: // 3-D Cell Reference [ 275]
719 : case 0x5C:
720 : case 0x7C:
721 : case 0x3C: // Deleted 3-D Cell Reference [ 277]
722 : {
723 : sal_uInt16 nTabFirst, nTabLast, nRow;
724 : sal_Int16 nExtSheet;
725 : sal_uInt8 nCol;
726 :
727 0 : aIn >> nExtSheet;
728 0 : aIn.Ignore( 8 );
729 0 : aIn >> nTabFirst >> nTabLast >> nRow >> nCol;
730 :
731 0 : if( nExtSheet >= 0 )
732 : { // from external
733 0 : if( rR.pExtSheetBuff->GetScTabIndex( nExtSheet, nTabLast ) )
734 : {
735 0 : nTabFirst = nTabLast;
736 0 : nExtSheet = 0; // found
737 : }
738 : else
739 : {
740 0 : aPool << ocBad;
741 0 : aPool >> aStack;
742 0 : nExtSheet = 1; // don't create a SingleRef
743 : }
744 : }
745 :
746 0 : if( nExtSheet <= 0 )
747 : { // in current Workbook
748 0 : aSRD.SetAbsTab(nTabFirst);
749 0 : aSRD.SetFlag3D(true);
750 :
751 0 : ExcRelToScRel( nRow, nCol, aSRD, bRangeName );
752 :
753 0 : switch ( nOp )
754 : {
755 : case 0x5C:
756 : case 0x7C:
757 : case 0x3C: // Deleted 3-D Cell Reference [ 277]
758 : // no information which part is deleted, set both
759 0 : aSRD.SetColDeleted( true );
760 0 : aSRD.SetRowDeleted( true );
761 : }
762 0 : if ( !ValidTab(static_cast<SCTAB>(nTabFirst)) )
763 0 : aSRD.SetTabDeleted( true );
764 :
765 0 : if( nTabLast != nTabFirst )
766 : {
767 0 : aCRD.Ref1 = aCRD.Ref2 = aSRD;
768 0 : aCRD.Ref2.SetAbsTab(nTabLast);
769 0 : aCRD.Ref2.SetTabDeleted( !ValidTab(static_cast<SCTAB>(nTabLast)) );
770 0 : aStack << aPool.Store( aCRD );
771 : }
772 : else
773 0 : aStack << aPool.Store( aSRD );
774 : }
775 : }
776 :
777 0 : break;
778 : case 0x5B:
779 : case 0x7B:
780 : case 0x3B: // 3-D Area Reference [ 276]
781 : case 0x5D:
782 : case 0x7D:
783 : case 0x3D: // Deleted 3-D Area Reference [ 277]
784 : {
785 : sal_uInt16 nTabFirst, nTabLast, nRowFirst, nRowLast;
786 : sal_Int16 nExtSheet;
787 : sal_uInt8 nColFirst, nColLast;
788 :
789 2 : aIn >> nExtSheet;
790 2 : aIn.Ignore( 8 );
791 2 : aIn >> nTabFirst >> nTabLast >> nRowFirst >> nRowLast
792 2 : >> nColFirst >> nColLast;
793 :
794 2 : if( nExtSheet >= 0 )
795 : // von extern
796 : {
797 0 : if( rR.pExtSheetBuff->GetScTabIndex( nExtSheet, nTabLast ) )
798 : {
799 0 : nTabFirst = nTabLast;
800 0 : nExtSheet = 0; // found
801 : }
802 : else
803 : {
804 0 : aPool << ocBad;
805 0 : aPool >> aStack;
806 0 : nExtSheet = 1; // don't create a CompleteRef
807 : }
808 : }
809 :
810 2 : if( nExtSheet <= 0 )
811 : {// in current Workbook
812 : // first part of range
813 2 : ScSingleRefData& rR1 = aCRD.Ref1;
814 2 : ScSingleRefData& rR2 = aCRD.Ref2;
815 :
816 2 : rR1.SetAbsTab(nTabFirst);
817 2 : rR2.SetAbsTab(nTabLast);
818 2 : rR1.SetFlag3D(true);
819 2 : rR2.SetFlag3D( nTabFirst != nTabLast );
820 :
821 2 : ExcRelToScRel( nRowFirst, nColFirst, aCRD.Ref1, bRangeName );
822 2 : ExcRelToScRel( nRowLast, nColLast, aCRD.Ref2, bRangeName );
823 :
824 2 : if( IsComplColRange( nColFirst, nColLast ) )
825 0 : SetComplCol( aCRD );
826 2 : else if( IsComplRowRange( nRowFirst, nRowLast ) )
827 0 : SetComplRow( aCRD );
828 :
829 2 : switch ( nOp )
830 : {
831 : case 0x5D:
832 : case 0x7D:
833 : case 0x3D: // Deleted 3-D Area Reference [ 277]
834 : // no information which part is deleted, set all
835 0 : rR1.SetColDeleted( true );
836 0 : rR1.SetRowDeleted( true );
837 0 : rR2.SetColDeleted( true );
838 0 : rR2.SetRowDeleted( true );
839 : }
840 2 : if ( !ValidTab(static_cast<SCTAB>(nTabFirst)) )
841 0 : rR1.SetTabDeleted( true );
842 2 : if ( !ValidTab(static_cast<SCTAB>(nTabLast)) )
843 0 : rR2.SetTabDeleted( true );
844 :
845 2 : aStack << aPool.Store( aCRD );
846 : }//END in current Workbook
847 : }
848 2 : break;
849 0 : default: bError = true;
850 : }
851 262 : bError |= !aIn.IsValid();
852 : }
853 :
854 : ConvErr eRet;
855 :
856 90 : if( bError )
857 : {
858 0 : aPool << ocBad;
859 0 : aPool >> aStack;
860 0 : pErgebnis = aPool[ aStack.Get() ];
861 0 : eRet = ConvErrNi;
862 : }
863 90 : else if( aIn.GetRecPos() != nEndPos )
864 : {
865 0 : aPool << ocBad;
866 0 : aPool >> aStack;
867 0 : pErgebnis = aPool[ aStack.Get() ];
868 0 : eRet = ConvErrCount;
869 : }
870 90 : else if( bExternName )
871 : {
872 0 : pErgebnis = aPool[ aStack.Get() ];
873 0 : eRet = ConvErrExternal;
874 : }
875 90 : else if( bArrayFormula )
876 : {
877 0 : pErgebnis = NULL;
878 0 : eRet = ConvOK;
879 : }
880 : else
881 : {
882 90 : pErgebnis = aPool[ aStack.Get() ];
883 90 : eRet = ConvOK;
884 : }
885 :
886 90 : aIn.Seek( nEndPos );
887 :
888 90 : if( eRet == ConvOK )
889 90 : ReadExtensions( aExtensions, aIn );
890 :
891 180 : return eRet;
892 : }
893 :
894 : // stream seeks to first byte after <nFormulaLen>
895 0 : ConvErr ExcelToSc::Convert( _ScRangeListTabs& rRangeList, XclImpStream& aIn, sal_Size nFormulaLen,
896 : SCsTAB nTab, const FORMULA_TYPE eFT )
897 : {
898 0 : RootData& rR = GetOldRoot();
899 : sal_uInt8 nOp, nLen;
900 : sal_Size nIgnore;
901 : sal_uInt16 nUINT16;
902 : sal_uInt8 nByte;
903 0 : bool bError = false;
904 0 : const bool bRangeName = eFT == FT_RangeName;
905 0 : const bool bSharedFormula = eFT == FT_SharedFormula;
906 0 : const bool bRNorSF = bRangeName || bSharedFormula;
907 :
908 : ScSingleRefData aSRD;
909 : ScComplexRefData aCRD;
910 0 : aCRD.Ref1.SetAbsTab(aEingPos.Tab());
911 0 : aCRD.Ref2.SetAbsTab(aEingPos.Tab());
912 :
913 0 : bExternName = false;
914 :
915 0 : if( eStatus != ConvOK )
916 : {
917 0 : aIn.Ignore( nFormulaLen );
918 0 : return eStatus;
919 : }
920 :
921 0 : if( nFormulaLen == 0 )
922 0 : return ConvOK;
923 :
924 0 : sal_Size nEndPos = aIn.GetRecPos() + nFormulaLen;
925 :
926 0 : while( (aIn.GetRecPos() < nEndPos) && !bError )
927 : {
928 0 : aIn >> nOp;
929 0 : nIgnore = 0;
930 :
931 : // always reset flags
932 0 : aSRD.InitFlags();
933 0 : aCRD.InitFlags();
934 :
935 0 : switch( nOp ) // book page:
936 : { // SDK4 SDK5
937 : case 0x01: // Array Formula [325 ]
938 : // Array Formula or Shared Formula [ 277]
939 0 : nIgnore = (meBiff == EXC_BIFF2) ? 3 : 4;
940 0 : break;
941 : case 0x02: // Data Table [325 277]
942 0 : nIgnore = (meBiff == EXC_BIFF2) ? 3 : 4;
943 0 : break;
944 : case 0x03: // Addition [312 264]
945 : case 0x04: // Subtraction [313 264]
946 : case 0x05: // Multiplication [313 264]
947 : case 0x06: // Division [313 264]
948 : case 0x07: // Exponetiation [313 265]
949 : case 0x08: // Concatenation [313 265]
950 : case 0x09: // Less Than [313 265]
951 : case 0x0A: // Less Than or Equal [313 265]
952 : case 0x0B: // Equal [313 265]
953 : case 0x0C: // Greater Than or Equal [313 265]
954 : case 0x0D: // Greater Than [313 265]
955 : case 0x0E: // Not Equal [313 265]
956 : case 0x0F: // Intersection [314 265]
957 : case 0x10: // Union [314 265]
958 : case 0x11: // Range [314 265]
959 : case 0x12: // Unary Plus [312 264]
960 : case 0x13: // Unary Minus [312 264]
961 : case 0x14: // Percent Sign [312 264]
962 : case 0x15: // Parenthesis [326 278]
963 : case 0x16: // Missing Argument [314 266]
964 0 : break;
965 : case 0x17: // String Constant [314 266]
966 0 : aIn >> nLen;
967 0 : nIgnore = nLen;
968 0 : break;
969 : case 0x19: // Special Attribute [327 279]
970 : {
971 0 : sal_uInt16 nData(0), nFakt(0);
972 0 : sal_uInt8 nOpt(0);
973 :
974 0 : aIn >> nOpt;
975 :
976 0 : if( meBiff == EXC_BIFF2 )
977 : {
978 0 : nData = aIn.ReaduInt8();
979 0 : nFakt = 1;
980 : }
981 : else
982 : {
983 0 : aIn >> nData;
984 0 : nFakt = 2;
985 : }
986 :
987 0 : if( nOpt & 0x04 )
988 : {
989 : // nFakt -> skip bytes or words AttrChoose
990 0 : ++nData;
991 0 : aIn.Ignore(static_cast<sal_Size>(nData) * nFakt);
992 : }
993 : }
994 0 : break;
995 : case 0x1A: // External Reference [330 ]
996 0 : switch( meBiff )
997 : {
998 0 : case EXC_BIFF2: nIgnore = 7; break;
999 : case EXC_BIFF3:
1000 0 : case EXC_BIFF4: nIgnore = 10; break;
1001 : case EXC_BIFF5: DBG_WARNING( "-ExcelToSc::Convert(): 0x1A does not exist in Biff5!" );
1002 : //fall-through
1003 : default: DBG_WARNING( "-ExcelToSc::Convert(): A little oblivious?" );
1004 : }
1005 0 : break;
1006 : case 0x1B: // End External Reference [330 ]
1007 0 : switch( meBiff )
1008 : {
1009 0 : case EXC_BIFF2: nIgnore = 3; break;
1010 : case EXC_BIFF3:
1011 0 : case EXC_BIFF4: nIgnore = 4; break;
1012 : case EXC_BIFF5: DBG_WARNING( "-ExcelToSc::Convert(): 0x1B does not exist in Biff5!" );
1013 : //fall-through
1014 : default: DBG_WARNING( "-ExcelToSc::Convert(): A little oblivious?" );
1015 : }
1016 0 : break;
1017 : case 0x1C: // Error Value [314 266]
1018 : case 0x1D: // Boolean [315 266]
1019 0 : nIgnore = 1;
1020 0 : break;
1021 : case 0x1E: // Integer [315 266]
1022 0 : nIgnore = 2;
1023 0 : break;
1024 : case 0x1F: // Number [315 266]
1025 0 : nIgnore = 8;
1026 0 : break;
1027 : case 0x40:
1028 : case 0x60:
1029 : case 0x20: // Array Constant [317 268]
1030 0 : nIgnore = (meBiff == EXC_BIFF2) ? 6 : 7;
1031 0 : break;
1032 : case 0x41:
1033 : case 0x61:
1034 : case 0x21: // Function, Fixed Number of Arguments [333 282]
1035 0 : nIgnore = (meBiff <= EXC_BIFF3) ? 1 : 2;
1036 0 : break;
1037 : case 0x42:
1038 : case 0x62:
1039 : case 0x22: // Function, Variable Number of Arg. [333 283]
1040 0 : nIgnore = (meBiff <= EXC_BIFF3) ? 2 : 3;
1041 0 : break;
1042 : case 0x43:
1043 : case 0x63:
1044 : case 0x23: // Name [318 269]
1045 0 : switch( meBiff )
1046 : {
1047 0 : case EXC_BIFF2: nIgnore = 7; break;
1048 : case EXC_BIFF3:
1049 0 : case EXC_BIFF4: nIgnore = 10; break;
1050 0 : case EXC_BIFF5: nIgnore = 14; break;
1051 : default: OSL_FAIL( "-ExcelToSc::Convert(): A little oblivious?" );
1052 : }
1053 0 : break;
1054 : case 0x44:
1055 : case 0x64:
1056 : case 0x24: // Cell Reference [319 270]
1057 0 : aIn >> nUINT16 >> nByte;
1058 0 : aSRD.SetAbsCol(static_cast<SCsCOL>(nByte));
1059 0 : aSRD.SetAbsRow(nUINT16 & 0x3FFF);
1060 0 : aSRD.SetRelTab(0);
1061 0 : aSRD.SetFlag3D( bRangeName );
1062 :
1063 0 : ExcRelToScRel( nUINT16, nByte, aSRD, bRangeName );
1064 :
1065 0 : rRangeList.Append(aSRD.toAbs(aEingPos), nTab);
1066 0 : break;
1067 : case 0x45:
1068 : case 0x65:
1069 : case 0x25: // Area Reference [320 270]
1070 : {
1071 : sal_uInt16 nRowFirst, nRowLast;
1072 : sal_uInt8 nColFirst, nColLast;
1073 0 : ScSingleRefData &rSRef1 = aCRD.Ref1;
1074 0 : ScSingleRefData &rSRef2 = aCRD.Ref2;
1075 :
1076 0 : aIn >> nRowFirst >> nRowLast >> nColFirst >> nColLast;
1077 :
1078 0 : rSRef1.SetRelTab(0);
1079 0 : rSRef2.SetRelTab(0);
1080 0 : rSRef1.SetFlag3D( bRangeName );
1081 0 : rSRef2.SetFlag3D( bRangeName );
1082 :
1083 0 : ExcRelToScRel( nRowFirst, nColFirst, aCRD.Ref1, bRangeName );
1084 0 : ExcRelToScRel( nRowLast, nColLast, aCRD.Ref2, bRangeName );
1085 :
1086 0 : if( IsComplColRange( nColFirst, nColLast ) )
1087 0 : SetComplCol( aCRD );
1088 0 : else if( IsComplRowRange( nRowFirst, nRowLast ) )
1089 0 : SetComplRow( aCRD );
1090 :
1091 0 : rRangeList.Append(aCRD.toAbs(aEingPos), nTab);
1092 : }
1093 0 : break;
1094 : case 0x46:
1095 : case 0x66:
1096 : case 0x26: // Constant Reference Subexpression [321 271]
1097 : case 0x47:
1098 : case 0x67:
1099 : case 0x27: // Erroneous Constant Reference Subexpr. [322 272]
1100 : case 0x48:
1101 : case 0x68:
1102 : case 0x28: // Incomplete Constant Reference Subexpr.[331 281]
1103 0 : nIgnore = (meBiff == EXC_BIFF2) ? 4 : 6;
1104 0 : break;
1105 : case 0x4A:
1106 : case 0x6A:
1107 : case 0x2A: // Deleted Cell Reference [323 273]
1108 0 : nIgnore = 3;
1109 0 : break;
1110 : case 0x4B:
1111 : case 0x6B:
1112 : case 0x2B: // Deleted Area Refernce [323 273]
1113 0 : nIgnore = 6;
1114 0 : break;
1115 : case 0x4C:
1116 : case 0x6C:
1117 : case 0x2C: // Cell Reference Within a Name [323 ]
1118 : // Cell Reference Within a Shared Formula[ 273]
1119 : {
1120 0 : aIn >> nUINT16 >> nByte; // >> Attribute, Row >> Col
1121 :
1122 0 : aSRD.SetRelTab(0);
1123 0 : aSRD.SetFlag3D( bRangeName );
1124 :
1125 0 : ExcRelToScRel( nUINT16, nByte, aSRD, bRNorSF );
1126 :
1127 0 : rRangeList.Append(aSRD.toAbs(aEingPos), nTab);
1128 : }
1129 0 : break;
1130 : case 0x4D:
1131 : case 0x6D:
1132 : case 0x2D: // Area Reference Within a Name [324 ]
1133 : { // Area Reference Within a Shared Formula[ 274]
1134 : sal_uInt16 nRowFirst, nRowLast;
1135 : sal_uInt8 nColFirst, nColLast;
1136 :
1137 0 : aCRD.Ref1.SetRelTab(0);
1138 0 : aCRD.Ref2.SetRelTab(0);
1139 0 : aCRD.Ref1.SetFlag3D( bRangeName );
1140 0 : aCRD.Ref2.SetFlag3D( bRangeName );
1141 :
1142 0 : aIn >> nRowFirst >> nRowLast >> nColFirst >> nColLast;
1143 :
1144 0 : ExcRelToScRel( nRowFirst, nColFirst, aCRD.Ref1, bRNorSF );
1145 0 : ExcRelToScRel( nRowLast, nColLast, aCRD.Ref2, bRNorSF );
1146 :
1147 0 : if( IsComplColRange( nColFirst, nColLast ) )
1148 0 : SetComplCol( aCRD );
1149 0 : else if( IsComplRowRange( nRowFirst, nRowLast ) )
1150 0 : SetComplRow( aCRD );
1151 :
1152 0 : rRangeList.Append(aCRD.toAbs(aEingPos), nTab);
1153 : }
1154 0 : break;
1155 : case 0x49:
1156 : case 0x69:
1157 : case 0x29: // Variable Reference Subexpression [331 281]
1158 : case 0x4E:
1159 : case 0x6E:
1160 : case 0x2E: // Reference Subexpression Within a Name [332 282]
1161 : case 0x4F:
1162 : case 0x6F:
1163 : case 0x2F: // Incomplete Reference Subexpression... [332 282]
1164 0 : nIgnore = (meBiff == EXC_BIFF2) ? 1 : 2;
1165 0 : break;
1166 : case 0x58:
1167 : case 0x78:
1168 : case 0x38: // Command-Equivalent Function [333 ]
1169 0 : nIgnore = 2;
1170 0 : break;
1171 : case 0x59:
1172 : case 0x79:
1173 : case 0x39: // Name or External Name [ 275]
1174 0 : nIgnore = 24;
1175 0 : break;
1176 : case 0x5A:
1177 : case 0x7A:
1178 : case 0x3A: // 3-D Cell Reference [ 275]
1179 : {
1180 : sal_uInt16 nTabFirst, nTabLast, nRow;
1181 : sal_Int16 nExtSheet;
1182 : sal_uInt8 nCol;
1183 :
1184 0 : aIn >> nExtSheet;
1185 0 : aIn.Ignore( 8 );
1186 0 : aIn >> nTabFirst >> nTabLast >> nRow >> nCol;
1187 :
1188 0 : if( nExtSheet >= 0 )
1189 : // from external
1190 : {
1191 0 : if( rR.pExtSheetBuff->GetScTabIndex( nExtSheet, nTabLast ) )
1192 : {
1193 0 : nTabFirst = nTabLast;
1194 0 : nExtSheet = 0; // found
1195 : }
1196 : else
1197 : {
1198 0 : aPool << ocBad;
1199 0 : aPool >> aStack;
1200 0 : nExtSheet = 1; // don't create a SingleRef
1201 : }
1202 : }
1203 :
1204 0 : if( nExtSheet <= 0 )
1205 : {// in current Workbook
1206 0 : bool b3D = ( static_cast<SCTAB>(nTabFirst) != aEingPos.Tab() ) || bRangeName;
1207 0 : aSRD.SetAbsTab(nTabFirst);
1208 0 : aSRD.SetFlag3D( b3D );
1209 :
1210 0 : ExcRelToScRel( nRow, nCol, aSRD, bRangeName );
1211 :
1212 0 : if( nTabLast != nTabFirst )
1213 : {
1214 0 : aCRD.Ref1 = aSRD;
1215 0 : aCRD.Ref2 = aSRD;
1216 0 : aCRD.Ref2.SetAbsTab(static_cast<SCTAB>(nTabLast));
1217 0 : b3D = ( static_cast<SCTAB>(nTabLast) != aEingPos.Tab() );
1218 0 : aCRD.Ref2.SetFlag3D( b3D );
1219 0 : rRangeList.Append(aCRD.toAbs(aEingPos), nTab);
1220 : }
1221 : else
1222 0 : rRangeList.Append(aSRD.toAbs(aEingPos), nTab);
1223 : }
1224 : }
1225 :
1226 0 : break;
1227 : case 0x5B:
1228 : case 0x7B:
1229 : case 0x3B: // 3-D Area Reference [ 276]
1230 : {
1231 : sal_uInt16 nTabFirst, nTabLast, nRowFirst, nRowLast;
1232 : sal_Int16 nExtSheet;
1233 : sal_uInt8 nColFirst, nColLast;
1234 :
1235 0 : aIn >> nExtSheet;
1236 0 : aIn.Ignore( 8 );
1237 0 : aIn >> nTabFirst >> nTabLast >> nRowFirst >> nRowLast
1238 0 : >> nColFirst >> nColLast;
1239 :
1240 0 : if( nExtSheet >= 0 )
1241 : // from external
1242 : {
1243 0 : if( rR.pExtSheetBuff->GetScTabIndex( nExtSheet, nTabLast ) )
1244 : {
1245 0 : nTabFirst = nTabLast;
1246 0 : nExtSheet = 0; // found
1247 : }
1248 : else
1249 : {
1250 0 : aPool << ocBad;
1251 0 : aPool >> aStack;
1252 0 : nExtSheet = 1; // don't create a CompleteRef
1253 : }
1254 : }
1255 :
1256 0 : if( nExtSheet <= 0 )
1257 : {// in current Workbook
1258 : // first part of range
1259 0 : ScSingleRefData &rR1 = aCRD.Ref1;
1260 0 : ScSingleRefData &rR2 = aCRD.Ref2;
1261 :
1262 0 : rR1.SetAbsTab(nTabFirst);
1263 0 : rR2.SetAbsTab(nTabLast);
1264 0 : rR1.SetFlag3D( ( static_cast<SCTAB>(nTabFirst) != aEingPos.Tab() ) || bRangeName );
1265 0 : rR2.SetFlag3D( ( static_cast<SCTAB>(nTabLast) != aEingPos.Tab() ) || bRangeName );
1266 :
1267 0 : ExcRelToScRel( nRowFirst, nColFirst, aCRD.Ref1, bRangeName );
1268 0 : ExcRelToScRel( nRowLast, nColLast, aCRD.Ref2, bRangeName );
1269 :
1270 0 : if( IsComplColRange( nColFirst, nColLast ) )
1271 0 : SetComplCol( aCRD );
1272 0 : else if( IsComplRowRange( nRowFirst, nRowLast ) )
1273 0 : SetComplRow( aCRD );
1274 :
1275 0 : rRangeList.Append(aCRD.toAbs(aEingPos), nTab);
1276 : }//END in current Workbook
1277 : }
1278 0 : break;
1279 : case 0x5C:
1280 : case 0x7C:
1281 : case 0x3C: // Deleted 3-D Cell Reference [ 277]
1282 0 : nIgnore = 17;
1283 0 : break;
1284 : case 0x5D:
1285 : case 0x7D:
1286 : case 0x3D: // Deleted 3-D Area Reference [ 277]
1287 0 : nIgnore = 20;
1288 0 : break;
1289 0 : default: bError = true;
1290 : }
1291 0 : bError |= !aIn.IsValid();
1292 :
1293 0 : aIn.Ignore( nIgnore );
1294 : }
1295 :
1296 : ConvErr eRet;
1297 :
1298 0 : if( bError )
1299 0 : eRet = ConvErrNi;
1300 0 : else if( aIn.GetRecPos() != nEndPos )
1301 0 : eRet = ConvErrCount;
1302 0 : else if( bExternName )
1303 0 : eRet = ConvErrExternal;
1304 : else
1305 0 : eRet = ConvOK;
1306 :
1307 0 : aIn.Seek( nEndPos );
1308 0 : return eRet;
1309 : }
1310 :
1311 0 : ConvErr ExcelToSc::ConvertExternName( const ScTokenArray*& /*rpArray*/, XclImpStream& /*rStrm*/, sal_Size /*nFormulaLen*/,
1312 : const OUString& /*rUrl*/, const vector<OUString>& /*rTabNames*/ )
1313 : {
1314 : // not implemented ...
1315 0 : return ConvErrNi;
1316 : }
1317 :
1318 0 : bool ExcelToSc::GetAbsRefs( ScRangeList& rRangeList, XclImpStream& rStrm, sal_Size nLen )
1319 : {
1320 : OSL_ENSURE_BIFF( GetBiff() == EXC_BIFF5 );
1321 0 : if( GetBiff() != EXC_BIFF5 )
1322 0 : return false;
1323 :
1324 : sal_uInt8 nOp;
1325 : sal_uInt16 nRow1, nRow2;
1326 : sal_uInt8 nCol1, nCol2;
1327 : SCTAB nTab1, nTab2;
1328 : sal_uInt16 nTabFirst, nTabLast;
1329 : sal_Int16 nRefIdx;
1330 :
1331 : sal_Size nSeek;
1332 0 : sal_Size nEndPos = rStrm.GetRecPos() + nLen;
1333 :
1334 0 : while( rStrm.IsValid() && (rStrm.GetRecPos() < nEndPos) )
1335 : {
1336 0 : rStrm >> nOp;
1337 0 : nSeek = 0;
1338 :
1339 0 : switch( nOp )
1340 : {
1341 : case 0x44:
1342 : case 0x64:
1343 : case 0x24: // Cell Reference [319 270]
1344 : case 0x4C:
1345 : case 0x6C:
1346 : case 0x2C: // Cell Reference Within a Name [323 ]
1347 : // Cell Reference Within a Shared Formula[ 273]
1348 0 : rStrm >> nRow1 >> nCol1;
1349 :
1350 0 : nRow2 = nRow1;
1351 0 : nCol2 = nCol1;
1352 0 : nTab1 = nTab2 = GetCurrScTab();
1353 0 : goto _common;
1354 : case 0x45:
1355 : case 0x65:
1356 : case 0x25: // Area Reference [320 270]
1357 : case 0x4D:
1358 : case 0x6D:
1359 : case 0x2D: // Area Reference Within a Name [324 ]
1360 : // Area Reference Within a Shared Formula[ 274]
1361 0 : rStrm >> nRow1 >> nRow2 >> nCol1 >> nCol2;
1362 :
1363 0 : nTab1 = nTab2 = GetCurrScTab();
1364 0 : goto _common;
1365 : case 0x5A:
1366 : case 0x7A:
1367 : case 0x3A: // 3-D Cell Reference [ 275]
1368 0 : rStrm >> nRefIdx;
1369 0 : rStrm.Ignore( 8 );
1370 0 : rStrm >> nTabFirst >> nTabLast >> nRow1 >> nCol1;
1371 :
1372 0 : nRow2 = nRow1;
1373 0 : nCol2 = nCol1;
1374 :
1375 0 : goto _3d_common;
1376 : case 0x5B:
1377 : case 0x7B:
1378 : case 0x3B: // 3-D Area Reference [ 276]
1379 0 : rStrm >> nRefIdx;
1380 0 : rStrm.Ignore( 8 );
1381 0 : rStrm >> nTabFirst >> nTabLast >> nRow1 >> nRow2 >> nCol1 >> nCol2;
1382 :
1383 : _3d_common:
1384 0 : nTab1 = static_cast< SCTAB >( nTabFirst );
1385 0 : nTab2 = static_cast< SCTAB >( nTabLast );
1386 :
1387 : // skip references to deleted sheets
1388 0 : if( (nRefIdx >= 0) || !ValidTab( nTab1 ) || (nTab1 != nTab2) )
1389 0 : break;
1390 :
1391 0 : goto _common;
1392 : _common:
1393 : // do not check abs/rel flags, linked controls have set them!
1394 : {
1395 0 : ScRange aScRange;
1396 0 : nRow1 &= 0x3FFF;
1397 0 : nRow2 &= 0x3FFF;
1398 0 : if( GetAddressConverter().ConvertRange( aScRange, XclRange( nCol1, nRow1, nCol2, nRow2 ), nTab1, nTab2, true ) )
1399 0 : rRangeList.Append( aScRange );
1400 : }
1401 0 : break;
1402 :
1403 : case 0x03: // Addition [312 264]
1404 : case 0x04: // Subtraction [313 264]
1405 : case 0x05: // Multiplication [313 264]
1406 : case 0x06: // Division [313 264]
1407 : case 0x07: // Exponetiation [313 265]
1408 : case 0x08: // Concatenation [313 265]
1409 : case 0x09: // Less Than [313 265]
1410 : case 0x0A: // Less Than or Equal [313 265]
1411 : case 0x0B: // Equal [313 265]
1412 : case 0x0C: // Greater Than or Equal [313 265]
1413 : case 0x0D: // Greater Than [313 265]
1414 : case 0x0E: // Not Equal [313 265]
1415 : case 0x0F: // Intersection [314 265]
1416 : case 0x10: // Union [314 265]
1417 : case 0x11: // Range [314 265]
1418 : case 0x12: // Unary Plus [312 264]
1419 : case 0x13: // Unary Minus [312 264]
1420 : case 0x14: // Percent Sign [312 264]
1421 : case 0x15: // Parenthesis [326 278]
1422 : case 0x16: // Missing Argument [314 266]
1423 0 : break;
1424 : case 0x1C: // Error Value [314 266]
1425 : case 0x1D: // Boolean [315 266]
1426 0 : nSeek = 1;
1427 0 : break;
1428 : case 0x1E: // Integer [315 266]
1429 : case 0x41:
1430 : case 0x61:
1431 : case 0x21: // Function, Fixed Number of Arguments [333 282]
1432 : case 0x49:
1433 : case 0x69:
1434 : case 0x29: // Variable Reference Subexpression [331 281]
1435 : case 0x4E:
1436 : case 0x6E:
1437 : case 0x2E: // Reference Subexpression Within a Name [332 282]
1438 : case 0x4F:
1439 : case 0x6F:
1440 : case 0x2F: // Incomplete Reference Subexpression... [332 282]
1441 : case 0x58:
1442 : case 0x78:
1443 : case 0x38: // Command-Equivalent Function [333 ]
1444 0 : nSeek = 2;
1445 0 : break;
1446 : case 0x42:
1447 : case 0x62:
1448 : case 0x22: // Function, Variable Number of Arg. [333 283]
1449 : case 0x4A:
1450 : case 0x6A:
1451 : case 0x2A: // Deleted Cell Reference [323 273]
1452 0 : nSeek = 3;
1453 0 : break;
1454 : case 0x01: // Array Formula [325 ]
1455 : // Array Formula or Shared Formula [ 277]
1456 : case 0x02: // Data Table [325 277]
1457 0 : nSeek = 4;
1458 0 : break;
1459 : case 0x46:
1460 : case 0x66:
1461 : case 0x26: // Constant Reference Subexpression [321 271]
1462 : case 0x47:
1463 : case 0x67:
1464 : case 0x27: // Erroneous Constant Reference Subexpr. [322 272]
1465 : case 0x48:
1466 : case 0x68:
1467 : case 0x28: // Incomplete Constant Reference Subexpr.[331 281]
1468 : case 0x4B:
1469 : case 0x6B:
1470 : case 0x2B: // Deleted Area Refernce [323 273]
1471 0 : nSeek = 6;
1472 0 : break;
1473 : case 0x40:
1474 : case 0x60:
1475 : case 0x20: // Array Constant [317 268]
1476 0 : nSeek = 7;
1477 0 : break;
1478 : case 0x1F: // Number [315 266]
1479 0 : nSeek = 8;
1480 0 : break;
1481 : case 0x43:
1482 : case 0x63:
1483 : case 0x23: // Name [318 269]
1484 0 : nSeek = 14;
1485 0 : break;
1486 : case 0x5C:
1487 : case 0x7C:
1488 : case 0x3C: // Deleted 3-D Cell Reference [ 277]
1489 0 : nSeek = 17;
1490 0 : break;
1491 : case 0x5D:
1492 : case 0x7D:
1493 : case 0x3D: // Deleted 3-D Area Reference [ 277]
1494 0 : nSeek = 20;
1495 0 : break;
1496 : case 0x59:
1497 : case 0x79:
1498 : case 0x39: // Name or External Name [ 275]
1499 0 : nSeek = 24;
1500 0 : break;
1501 : case 0x17: // String Constant [314 266]
1502 0 : nSeek = rStrm.ReaduInt8();
1503 0 : break;
1504 : case 0x19: // Special Attribute [327 279]
1505 : {
1506 : sal_uInt8 nOpt;
1507 : sal_uInt16 nData;
1508 0 : rStrm >> nOpt >> nData;
1509 0 : if( nOpt & 0x04 )
1510 0 : nSeek = nData * 2 + 2;
1511 : }
1512 0 : break;
1513 : }
1514 :
1515 0 : rStrm.Ignore( nSeek );
1516 : }
1517 0 : rStrm.Seek( nEndPos );
1518 :
1519 0 : return !rRangeList.empty();
1520 : }
1521 :
1522 6776 : void ExcelToSc::DoMulArgs( DefTokenId eId, sal_uInt8 nAnz )
1523 : {
1524 6776 : TokenId eParam[ 256 ];
1525 : sal_Int32 nLauf;
1526 :
1527 6776 : if( eId == ocCeil || eId == ocFloor )
1528 : {
1529 0 : aStack << aPool.Store( 1.0 ); // default, because not present in Excel
1530 0 : nAnz++;
1531 : }
1532 :
1533 20534 : for( nLauf = 0; aStack.HasMoreTokens() && (nLauf < nAnz); nLauf++ )
1534 13758 : aStack >> eParam[ nLauf ];
1535 : // #i70925# reduce parameter count, if no more tokens available on token stack
1536 6776 : if( nLauf < nAnz )
1537 0 : nAnz = static_cast< sal_uInt8 >( nLauf );
1538 :
1539 6776 : if( nAnz > 0 && eId == ocExternal )
1540 : {
1541 354 : TokenId n = eParam[ nAnz - 1 ];
1542 : //##### GRUETZE FUER BASIC-FUNCS RICHTEN!
1543 354 : if( const OUString* pExt = aPool.GetExternal( n ) )
1544 : {
1545 354 : if( const XclFunctionInfo* pFuncInfo = maFuncProv.GetFuncInfoFromXclMacroName( *pExt ) )
1546 352 : aPool << pFuncInfo->meOpCode;
1547 : else
1548 2 : aPool << n;
1549 354 : nAnz--;
1550 : }
1551 : else
1552 0 : aPool << eId;
1553 : }
1554 : else
1555 6422 : aPool << eId;
1556 :
1557 6776 : aPool << ocOpen;
1558 :
1559 6776 : if( nAnz > 0 )
1560 : {
1561 : // attention: 0 = last parameter, nAnz-1 = first parameter
1562 6760 : sal_Int16 nSkipEnd = -1; // skip all parameters <= nSkipEnd
1563 :
1564 6760 : sal_Int16 nLast = nAnz - 1;
1565 :
1566 : // functions for which parameters have to be skipped
1567 6760 : if( eId == ocPercentrank && nAnz == 3 )
1568 0 : nSkipEnd = 0; // skip last parameter if necessary
1569 :
1570 : // Joost special cases
1571 6760 : else if( eId == ocIf )
1572 : {
1573 8 : sal_uInt16 nNullParam = 0;
1574 28 : for( nLauf = 0 ; nLauf < nAnz ; nLauf++ )
1575 : {
1576 20 : if( aPool.IsSingleOp( eParam[ nLauf ], ocMissing ) )
1577 : {
1578 0 : if( !nNullParam )
1579 0 : nNullParam = (sal_uInt16) aPool.Store( ( double ) 0.0 );
1580 0 : eParam[ nLauf ] = nNullParam;
1581 : }
1582 : }
1583 : }
1584 :
1585 : // [Parameter{;Parameter}]
1586 6760 : if( nLast > nSkipEnd )
1587 : {
1588 6760 : sal_Int16 nNull = -1; // skip this parameter
1589 6760 : aPool << eParam[ nLast ];
1590 13404 : for( nLauf = nLast - 1 ; nLauf > nSkipEnd ; nLauf-- )
1591 : {
1592 6644 : if( nLauf != nNull )
1593 6644 : aPool << ocSep << eParam[ nLauf ];
1594 : }
1595 : }
1596 : }
1597 6776 : aPool << ocClose;
1598 :
1599 6776 : aPool >> aStack;
1600 6776 : }
1601 :
1602 180 : void ExcelToSc::ExcRelToScRel( sal_uInt16 nRow, sal_uInt8 nCol, ScSingleRefData &rSRD, const bool bName )
1603 : {
1604 180 : if( bName )
1605 : {
1606 : // C O L
1607 132 : if( nRow & 0x4000 )
1608 128 : rSRD.SetRelCol(nCol);
1609 : else
1610 4 : rSRD.SetAbsCol(nCol);
1611 :
1612 : // R O W
1613 132 : if( nRow & 0x8000 )
1614 : {// rel Row
1615 128 : if( nRow & 0x2000 ) // Bit 13 set?
1616 : // Row negative
1617 0 : rSRD.SetRelRow(nRow | 0xC000);
1618 : else
1619 : // Row positive
1620 128 : rSRD.SetRelRow(nRow & nRowMask);
1621 : }
1622 : else
1623 : {// abs Row
1624 4 : rSRD.SetAbsRow(nRow & nRowMask);
1625 : }
1626 :
1627 : // T A B
1628 : // abs needed if rel in shared formula for ScCompiler UpdateNameReference
1629 132 : if ( rSRD.IsTabRel() && !rSRD.IsFlag3D() )
1630 128 : rSRD.SetAbsTab(GetCurrScTab());
1631 : }
1632 : else
1633 : {
1634 48 : bool bColRel = (nRow & 0x4000) > 0;
1635 48 : bool bRowRel = (nRow & 0x8000) > 0;
1636 :
1637 48 : if (bColRel)
1638 48 : rSRD.SetRelCol(nCol - aEingPos.Col());
1639 : else
1640 0 : rSRD.SetAbsCol(nCol);
1641 :
1642 48 : rSRD.SetAbsRow(nRow & nRowMask);
1643 48 : if (bRowRel)
1644 48 : rSRD.SetRelRow(rSRD.Row() - aEingPos.Row());
1645 :
1646 : // T A B
1647 : // #i10184# abs needed if rel in shared formula for ScCompiler UpdateNameReference
1648 48 : if ( rSRD.IsTabRel() && !rSRD.IsFlag3D() )
1649 48 : rSRD.SetAbsTab(GetCurrScTab() + rSRD.Tab());
1650 : }
1651 180 : }
1652 :
1653 2 : const ScTokenArray* ExcelToSc::GetBoolErr( XclBoolError eType )
1654 : {
1655 : sal_uInt16 nError;
1656 2 : aPool.Reset();
1657 2 : aStack.Reset();
1658 :
1659 : DefTokenId eOc;
1660 :
1661 2 : switch( eType )
1662 : {
1663 0 : case xlErrNull: eOc = ocStop; nError = errNoCode; break;
1664 0 : case xlErrDiv0: eOc = ocStop; nError = errDivisionByZero; break;
1665 0 : case xlErrValue: eOc = ocStop; nError = errNoValue; break;
1666 0 : case xlErrRef: eOc = ocStop; nError = errNoRef; break;
1667 0 : case xlErrName: eOc = ocStop; nError = errNoName; break;
1668 0 : case xlErrNum: eOc = ocStop; nError = errIllegalFPOperation; break;
1669 0 : case xlErrNA: eOc = ocNotAvail; nError = NOTAVAILABLE; break;
1670 2 : case xlErrTrue: eOc = ocTrue; nError = 0; break;
1671 0 : case xlErrFalse: eOc = ocFalse; nError = 0; break;
1672 0 : case xlErrUnknown: eOc = ocStop; nError = errUnknownState; break;
1673 : default:
1674 : OSL_FAIL( "ExcelToSc::GetBoolErr - wrong enum!" );
1675 0 : eOc = ocNoName;
1676 0 : nError = errUnknownState;
1677 : }
1678 :
1679 2 : aPool << eOc;
1680 2 : if( eOc != ocStop )
1681 2 : aPool << ocOpen << ocClose;
1682 :
1683 2 : aPool >> aStack;
1684 :
1685 2 : const ScTokenArray* pErgebnis = aPool[ aStack.Get() ];
1686 2 : if( nError )
1687 0 : ( ( ScTokenArray* ) pErgebnis )->SetCodeError( nError );
1688 :
1689 2 : ( ( ScTokenArray* ) pErgebnis )->SetExclusiveRecalcModeNormal();
1690 :
1691 2 : return pErgebnis;
1692 : }
1693 :
1694 2268 : bool ExcelToSc::ReadSharedFormulaPosition( XclImpStream& rStrm, SCCOL& rCol, SCROW& rRow )
1695 : {
1696 2268 : rStrm.PushPosition();
1697 :
1698 : sal_uInt8 nOp;
1699 2268 : rStrm >> nOp;
1700 :
1701 2268 : if (nOp != 0x01) // must be PtgExp token.
1702 : {
1703 496 : rStrm.PopPosition();
1704 496 : return false;
1705 : }
1706 :
1707 : sal_uInt16 nRow, nCol;
1708 1772 : rStrm >> nRow >> nCol;
1709 1772 : rStrm.PopPosition();
1710 1772 : rCol = nCol;
1711 1772 : rRow = nRow;
1712 1772 : return true;
1713 : }
1714 :
1715 1772 : const ScTokenArray* ExcelToSc::GetSharedFormula( const ScAddress& rRefPos ) const
1716 : {
1717 1772 : return GetOldRoot().pShrfmlaBuff->Find(rRefPos);
1718 : }
1719 :
1720 2 : void ExcelToSc::SetError( ScFormulaCell &rCell, const ConvErr eErr )
1721 : {
1722 : sal_uInt16 nInd;
1723 :
1724 2 : switch( eErr )
1725 : {
1726 2 : case ConvErrNi: nInd = errUnknownToken; break;
1727 0 : case ConvErrNoMem: nInd = errCodeOverflow; break;
1728 0 : case ConvErrExternal: nInd = errNoName; break;
1729 0 : case ConvErrCount: nInd = errCodeOverflow; break;
1730 0 : default: nInd = errNoCode; // I had no better idea
1731 : }
1732 :
1733 2 : rCell.SetErrCode( nInd );
1734 2 : }
1735 :
1736 0 : void ExcelToSc::SetComplCol( ScComplexRefData &rCRD )
1737 : {
1738 0 : ScSingleRefData &rSRD = rCRD.Ref2;
1739 0 : if( rSRD.IsColRel() )
1740 0 : rSRD.SetRelCol(MAXCOL - aEingPos.Col());
1741 : else
1742 0 : rSRD.SetAbsCol(MAXCOL);
1743 0 : }
1744 :
1745 0 : void ExcelToSc::SetComplRow( ScComplexRefData &rCRD )
1746 : {
1747 0 : ScSingleRefData &rSRD = rCRD.Ref2;
1748 0 : if( rSRD.IsRowRel() )
1749 0 : rSRD.SetRelRow(MAXROW - aEingPos.Row());
1750 : else
1751 0 : rSRD.SetAbsRow(MAXROW);
1752 0 : }
1753 :
1754 14 : void ExcelToSc::ReadExtensionArray( unsigned int n, XclImpStream& aIn )
1755 : {
1756 : sal_uInt8 nByte;
1757 : sal_uInt16 nUINT16;
1758 : double fDouble;
1759 14 : OUString aString;
1760 : ScMatrix* pMatrix;
1761 :
1762 14 : aIn >> nByte >> nUINT16;
1763 :
1764 : SCSIZE nC, nCols;
1765 : SCSIZE nR, nRows;
1766 14 : if( GetBiff() == EXC_BIFF8 )
1767 : {
1768 14 : nCols = nByte + 1;
1769 14 : nRows = nUINT16 + 1;
1770 : }
1771 : else
1772 : {
1773 0 : nCols = nByte ? nByte : 256;
1774 0 : nRows = nUINT16;
1775 : }
1776 :
1777 14 : pMatrix = aPool.GetMatrix( n );
1778 :
1779 14 : if( NULL != pMatrix )
1780 : {
1781 14 : pMatrix->Resize(nCols, nRows);
1782 14 : pMatrix->GetDimensions( nC, nR);
1783 14 : if( nC != nCols || nR != nRows )
1784 : {
1785 : OSL_FAIL( "ExcelToSc::ReadExtensionArray - matrix size mismatch" );
1786 0 : pMatrix = NULL;
1787 : }
1788 : }
1789 : else
1790 : {
1791 : OSL_FAIL( "ExcelToSc::ReadExtensionArray - missing matrix" );
1792 : }
1793 :
1794 14 : svl::SharedStringPool& rPool = GetDoc().GetSharedStringPool();
1795 46 : for( nR = 0 ; nR < nRows; nR++ )
1796 : {
1797 108 : for( nC = 0 ; nC < nCols; nC++ )
1798 : {
1799 76 : aIn >> nByte;
1800 76 : switch( nByte )
1801 : {
1802 : case EXC_CACHEDVAL_EMPTY:
1803 0 : aIn.Ignore( 8 );
1804 0 : if( NULL != pMatrix )
1805 : {
1806 0 : pMatrix->PutEmpty( nC, nR );
1807 : }
1808 0 : break;
1809 :
1810 : case EXC_CACHEDVAL_DOUBLE:
1811 76 : aIn >> fDouble;
1812 76 : if( NULL != pMatrix )
1813 : {
1814 76 : pMatrix->PutDouble( fDouble, nC, nR );
1815 : }
1816 76 : break;
1817 :
1818 : case EXC_CACHEDVAL_STRING:
1819 0 : if( GetBiff() == EXC_BIFF8 )
1820 : {
1821 0 : aIn >> nUINT16;
1822 0 : aString = aIn.ReadUniString( nUINT16 );
1823 : }
1824 : else
1825 : {
1826 0 : aIn >> nByte;
1827 0 : aString = aIn.ReadRawByteString( nByte );
1828 : }
1829 0 : if( NULL != pMatrix )
1830 : {
1831 0 : pMatrix->PutString(rPool.intern(aString), nC, nR);
1832 : }
1833 0 : break;
1834 :
1835 : case EXC_CACHEDVAL_BOOL:
1836 0 : aIn >> nByte;
1837 0 : aIn.Ignore( 7 );
1838 0 : if( NULL != pMatrix )
1839 : {
1840 0 : pMatrix->PutBoolean( nByte != 0, nC, nR );
1841 : }
1842 0 : break;
1843 :
1844 : case EXC_CACHEDVAL_ERROR:
1845 0 : aIn >> nByte;
1846 0 : aIn.Ignore( 7 );
1847 0 : if( NULL != pMatrix )
1848 : {
1849 0 : pMatrix->PutError( XclTools::GetScErrorCode( nByte ), nC, nR );
1850 : }
1851 0 : break;
1852 : }
1853 : }
1854 14 : }
1855 14 : }
1856 :
1857 0 : void ExcelToSc::ReadExtensionNlr( XclImpStream& aIn )
1858 : {
1859 : sal_uInt32 nFlags;
1860 0 : aIn >> nFlags;
1861 :
1862 0 : sal_uInt32 nCount = nFlags & EXC_TOK_NLR_ADDMASK;
1863 0 : aIn.Ignore( nCount * 4 ); // Drop the cell positions
1864 0 : }
1865 :
1866 0 : void ExcelToSc::ReadExtensionMemArea( XclImpStream& aIn )
1867 : {
1868 0 : sal_uInt16 nCount(0);
1869 0 : aIn >> nCount;
1870 :
1871 0 : aIn.Ignore( static_cast<sal_Size>(nCount) * ((GetBiff() == EXC_BIFF8) ? 8 : 6) ); // drop the ranges
1872 0 : }
1873 :
1874 6088 : void ExcelToSc::ReadExtensions( const ExtensionTypeVec& rExtensions,
1875 : XclImpStream& aIn )
1876 : {
1877 6088 : unsigned int nArray = 0;
1878 :
1879 6102 : for( unsigned int i = 0 ; i < rExtensions.size() ; i++ )
1880 : {
1881 14 : ExtensionType eType = rExtensions[i];
1882 :
1883 14 : switch( eType )
1884 : {
1885 : case EXTENSION_ARRAY:
1886 14 : ReadExtensionArray( nArray++, aIn );
1887 14 : break;
1888 :
1889 : case EXTENSION_NLR:
1890 0 : ReadExtensionNlr( aIn );
1891 0 : break;
1892 :
1893 : case EXTENSION_MEMAREA:
1894 0 : ReadExtensionMemArea( aIn );
1895 0 : break;
1896 : }
1897 : }
1898 6136 : }
1899 :
1900 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
