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