9d29649e07
If a token from the original tokens, supplied to a parallel group calculation while RefCounting was disabled for those tokens, ends up as a FormulaResult token, then fix up the ref count when parallel calculation ends Change-Id: I2587c25d216ab170725017b67b97d203a578160b Reviewed-on: https://gerrit.libreoffice.org/c/core/+/166080 Tested-by: Jenkins Reviewed-by: Caolán McNamara <caolan.mcnamara@collabora.com>
517 lines
22 KiB
C++
517 lines
22 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#ifndef INCLUDED_FORMULA_TOKEN_HXX
|
|
#define INCLUDED_FORMULA_TOKEN_HXX
|
|
|
|
#include <sal/config.h>
|
|
|
|
#include <cstring>
|
|
#include <memory>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <formula/formuladllapi.h>
|
|
#include <formula/opcode.hxx>
|
|
#include <formula/types.hxx>
|
|
#include <formula/paramclass.hxx>
|
|
#include <osl/interlck.h>
|
|
#include <rtl/ustring.hxx>
|
|
#include <sal/types.h>
|
|
#include <svl/sharedstring.hxx>
|
|
|
|
class ScJumpMatrix;
|
|
class ScMatrix;
|
|
struct ScComplexRefData;
|
|
struct ScSingleRefData;
|
|
enum class FormulaError : sal_uInt16;
|
|
|
|
namespace formula
|
|
{
|
|
|
|
enum StackVar : sal_uInt8
|
|
{
|
|
svByte,
|
|
svDouble,
|
|
svString,
|
|
svSingleRef,
|
|
svDoubleRef,
|
|
svMatrix,
|
|
svIndex,
|
|
svJump,
|
|
svExternal, // Byte + String
|
|
svFAP, // FormulaAutoPilot only, ever exported
|
|
svJumpMatrix,
|
|
svRefList, // ocUnion result
|
|
svEmptyCell, // Result is an empty cell, e.g. in LOOKUP()
|
|
|
|
svMatrixCell, // Result is a matrix with bells and
|
|
// whistles as needed for _the_ matrix
|
|
// formula result.
|
|
|
|
svHybridCell, // A temporary condition of a formula
|
|
// cell during import, having a double
|
|
// and/or string result and a formula
|
|
// string to be compiled.
|
|
|
|
svExternalSingleRef,
|
|
svExternalDoubleRef,
|
|
svExternalName,
|
|
svSingleVectorRef,
|
|
svDoubleVectorRef,
|
|
svError, // error token
|
|
svMissing, // 0 or ""
|
|
svSep, // separator, ocSep, ocOpen, ocClose
|
|
svUnknown // unknown StackType
|
|
};
|
|
|
|
// Only to be used for debugging output. No guarantee of stability of the
|
|
// return value.
|
|
|
|
// Turn this into an operator<< when StackVar becomes a scoped enum
|
|
|
|
inline std::string StackVarEnumToString(StackVar const e)
|
|
{
|
|
switch (e)
|
|
{
|
|
case svByte: return "Byte";
|
|
case svDouble: return "Double";
|
|
case svString: return "String";
|
|
case svSingleRef: return "SingleRef";
|
|
case svDoubleRef: return "DoubleRef";
|
|
case svMatrix: return "Matrix";
|
|
case svIndex: return "Index";
|
|
case svJump: return "Jump";
|
|
case svExternal: return "External";
|
|
case svFAP: return "FAP";
|
|
case svJumpMatrix: return "JumpMatrix";
|
|
case svRefList: return "RefList";
|
|
case svEmptyCell: return "EmptyCell";
|
|
case svMatrixCell: return "MatrixCell";
|
|
case svHybridCell: return "HybridCell";
|
|
case svExternalSingleRef: return "ExternalSingleRef";
|
|
case svExternalDoubleRef: return "ExternalDoubleRef";
|
|
case svExternalName: return "ExternalName";
|
|
case svSingleVectorRef: return "SingleVectorRef";
|
|
case svDoubleVectorRef: return "DoubleVectorRef";
|
|
case svError: return "Error";
|
|
case svMissing: return "Missing";
|
|
case svSep: return "Sep";
|
|
case svUnknown: return "Unknown";
|
|
}
|
|
std::ostringstream os;
|
|
os << static_cast<int>(e);
|
|
return os.str();
|
|
}
|
|
|
|
enum class RefCntPolicy : sal_uInt8
|
|
{
|
|
ThreadSafe, // refcounting via thread-safe oslInterlockedCount
|
|
UnsafeRef, // refcounting done with no locking/guarding against concurrent access
|
|
None // no ref counting done
|
|
};
|
|
|
|
class FORMULA_DLLPUBLIC FormulaToken
|
|
{
|
|
OpCode eOp;
|
|
const StackVar eType; // type of data
|
|
RefCntPolicy eRefCntPolicy; // style of reference counting
|
|
mutable oslInterlockedCount mnRefCnt; // reference count
|
|
|
|
FormulaToken& operator=( const FormulaToken& ) = delete;
|
|
public:
|
|
FormulaToken( StackVar eTypeP,OpCode e = ocPush );
|
|
FormulaToken( const FormulaToken& r );
|
|
|
|
virtual ~FormulaToken();
|
|
|
|
void Delete() { delete this; }
|
|
void DeleteIfZeroRef() { if (mnRefCnt == 0) delete this; }
|
|
StackVar GetType() const { return eType; }
|
|
bool IsFunction() const; // pure functions, no operators
|
|
|
|
bool IsExternalRef() const;
|
|
bool IsRef() const;
|
|
|
|
sal_uInt8 GetParamCount() const;
|
|
|
|
void IncRef() const
|
|
{
|
|
switch (eRefCntPolicy)
|
|
{
|
|
case RefCntPolicy::ThreadSafe:
|
|
default:
|
|
osl_atomic_increment(&mnRefCnt);
|
|
break;
|
|
case RefCntPolicy::UnsafeRef:
|
|
++mnRefCnt;
|
|
break;
|
|
case RefCntPolicy::None:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void DecRef() const
|
|
{
|
|
switch (eRefCntPolicy)
|
|
{
|
|
case RefCntPolicy::ThreadSafe:
|
|
default:
|
|
if (!osl_atomic_decrement(&mnRefCnt))
|
|
const_cast<FormulaToken*>(this)->Delete();
|
|
break;
|
|
case RefCntPolicy::UnsafeRef:
|
|
if (!--mnRefCnt)
|
|
const_cast<FormulaToken*>(this)->Delete();
|
|
break;
|
|
case RefCntPolicy::None:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SetRefCntPolicy(RefCntPolicy ePolicy) { eRefCntPolicy = ePolicy; }
|
|
RefCntPolicy GetRefCntPolicy() const { return eRefCntPolicy; }
|
|
|
|
oslInterlockedCount GetRef() const { return mnRefCnt; }
|
|
OpCode GetOpCode() const { return eOp; }
|
|
|
|
bool IsInForceArray() const;
|
|
|
|
/**
|
|
Dummy methods to avoid switches and casts where possible,
|
|
the real token classes have to override the appropriate method[s].
|
|
The only methods valid anytime if not overridden are:
|
|
|
|
- GetByte() since this represents the count of parameters to a function
|
|
which of course is 0 on non-functions. FormulaByteToken and ScExternal do
|
|
override it.
|
|
|
|
- GetInForceArray() since also this is only used for operators and
|
|
functions and is ParamClass::Unknown for other tokens.
|
|
|
|
Any other non-overridden method pops up an assertion.
|
|
*/
|
|
|
|
virtual sal_uInt8 GetByte() const;
|
|
virtual void SetByte( sal_uInt8 n );
|
|
virtual ParamClass GetInForceArray() const;
|
|
virtual void SetInForceArray( ParamClass c );
|
|
virtual double GetDouble() const;
|
|
virtual void SetDouble(double fValue);
|
|
virtual sal_Int16 GetDoubleType() const;
|
|
virtual void SetDoubleType( sal_Int16 nType );
|
|
virtual const svl::SharedString & GetString() const;
|
|
virtual void SetString( const svl::SharedString& rStr );
|
|
virtual sal_uInt16 GetIndex() const;
|
|
virtual void SetIndex( sal_uInt16 n );
|
|
virtual sal_Int16 GetSheet() const;
|
|
virtual void SetSheet( sal_Int16 n );
|
|
virtual sal_Unicode GetChar() const;
|
|
virtual short* GetJump() const;
|
|
virtual const OUString& GetExternal() const;
|
|
virtual FormulaToken* GetFAPOrigToken() const;
|
|
virtual FormulaError GetError() const;
|
|
virtual void SetError( FormulaError );
|
|
|
|
virtual const ScSingleRefData* GetSingleRef() const;
|
|
virtual ScSingleRefData* GetSingleRef();
|
|
virtual const ScComplexRefData* GetDoubleRef() const;
|
|
virtual ScComplexRefData* GetDoubleRef();
|
|
virtual const ScSingleRefData* GetSingleRef2() const;
|
|
virtual ScSingleRefData* GetSingleRef2();
|
|
virtual const ScMatrix* GetMatrix() const;
|
|
virtual ScMatrix* GetMatrix();
|
|
virtual ScJumpMatrix* GetJumpMatrix() const;
|
|
virtual const std::vector<ScComplexRefData>* GetRefList() const;
|
|
virtual std::vector<ScComplexRefData>* GetRefList();
|
|
|
|
virtual FormulaToken* Clone() const { return new FormulaToken(*this); }
|
|
|
|
virtual bool TextEqual( const formula::FormulaToken& rToken ) const;
|
|
virtual bool operator==( const FormulaToken& rToken ) const;
|
|
|
|
/** This is dirty and only the compiler should use it! */
|
|
struct PrivateAccess { friend class FormulaCompiler; private: PrivateAccess() { } };
|
|
void NewOpCode( OpCode e, const PrivateAccess& ) { eOp = e; }
|
|
};
|
|
|
|
inline void intrusive_ptr_add_ref(const FormulaToken* p)
|
|
{
|
|
p->IncRef();
|
|
}
|
|
|
|
inline void intrusive_ptr_release(const FormulaToken* p)
|
|
{
|
|
p->DecRef();
|
|
}
|
|
|
|
class FORMULA_DLLPUBLIC FormulaSpaceToken final : public FormulaToken
|
|
{
|
|
private:
|
|
sal_uInt8 nByte;
|
|
sal_Unicode cChar;
|
|
public:
|
|
FormulaSpaceToken( sal_uInt8 n, sal_Unicode c ) :
|
|
FormulaToken( svByte, ocWhitespace ),
|
|
nByte( n ), cChar( c ) {}
|
|
FormulaSpaceToken( const FormulaSpaceToken& r ) :
|
|
FormulaToken( r ),
|
|
nByte( r.nByte ), cChar( r.cChar ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaSpaceToken(*this); }
|
|
virtual sal_uInt8 GetByte() const override;
|
|
virtual sal_Unicode GetChar() const override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
class FORMULA_DLLPUBLIC FormulaByteToken : public FormulaToken
|
|
{
|
|
private:
|
|
sal_uInt8 nByte;
|
|
ParamClass eInForceArray;
|
|
protected:
|
|
FormulaByteToken( OpCode e, sal_uInt8 n, StackVar v, ParamClass c ) :
|
|
FormulaToken( v,e ), nByte( n ),
|
|
eInForceArray( c ) {}
|
|
public:
|
|
FormulaByteToken( OpCode e, sal_uInt8 n, ParamClass c ) :
|
|
FormulaToken( svByte,e ), nByte( n ),
|
|
eInForceArray( c ) {}
|
|
FormulaByteToken( OpCode e, sal_uInt8 n ) :
|
|
FormulaToken( svByte,e ), nByte( n ),
|
|
eInForceArray( ParamClass::Unknown ) {}
|
|
FormulaByteToken( OpCode e ) :
|
|
FormulaToken( svByte,e ), nByte( 0 ),
|
|
eInForceArray( ParamClass::Unknown ) {}
|
|
FormulaByteToken( const FormulaByteToken& r ) :
|
|
FormulaToken( r ), nByte( r.nByte ),
|
|
eInForceArray( r.eInForceArray ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaByteToken(*this); }
|
|
virtual sal_uInt8 GetByte() const override final;
|
|
virtual void SetByte( sal_uInt8 n ) override final;
|
|
virtual ParamClass GetInForceArray() const override final;
|
|
virtual void SetInForceArray( ParamClass c ) override final;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
|
|
// A special token for the FormulaAutoPilot only. Keeps a reference pointer of
|
|
// the token of which it was created for comparison.
|
|
class FORMULA_DLLPUBLIC FormulaFAPToken final : public FormulaByteToken
|
|
{
|
|
private:
|
|
FormulaTokenRef pOrigToken;
|
|
public:
|
|
FormulaFAPToken( OpCode e, sal_uInt8 n, FormulaToken* p ) :
|
|
FormulaByteToken( e, n, svFAP, ParamClass::Unknown ),
|
|
pOrigToken( p ) {}
|
|
FormulaFAPToken( const FormulaFAPToken& r ) :
|
|
FormulaByteToken( r ), pOrigToken( r.pOrigToken ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaFAPToken(*this); }
|
|
virtual FormulaToken* GetFAPOrigToken() const override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
class FORMULA_DLLPUBLIC FormulaDoubleToken : public FormulaToken
|
|
{
|
|
private:
|
|
double fDouble;
|
|
public:
|
|
FormulaDoubleToken( double f ) :
|
|
FormulaToken( svDouble ), fDouble( f ) {}
|
|
FormulaDoubleToken( const FormulaDoubleToken& r ) :
|
|
FormulaToken( r ), fDouble( r.fDouble ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaDoubleToken(*this); }
|
|
virtual double GetDouble() const override final { return fDouble; }
|
|
virtual void SetDouble(double fValue) override final { fDouble = fValue; }
|
|
virtual sal_Int16 GetDoubleType() const override; ///< always returns 0 for "not typed"
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
class FORMULA_DLLPUBLIC FormulaTypedDoubleToken final : public FormulaDoubleToken
|
|
{
|
|
private:
|
|
sal_Int16 mnType; /**< Can hold, for example, a value
|
|
of SvNumFormatType, or by
|
|
contract any other
|
|
classification. */
|
|
public:
|
|
FormulaTypedDoubleToken( double f, sal_Int16 nType ) :
|
|
FormulaDoubleToken( f ), mnType( nType ) {}
|
|
FormulaTypedDoubleToken( const FormulaTypedDoubleToken& r ) :
|
|
FormulaDoubleToken( r ), mnType( r.mnType ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaTypedDoubleToken(*this); }
|
|
virtual sal_Int16 GetDoubleType() const override;
|
|
virtual void SetDoubleType( sal_Int16 nType ) override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
|
|
class FORMULA_DLLPUBLIC FormulaStringToken final : public FormulaToken
|
|
{
|
|
svl::SharedString maString;
|
|
public:
|
|
FormulaStringToken( svl::SharedString r );
|
|
FormulaStringToken( const FormulaStringToken& r );
|
|
|
|
virtual FormulaToken* Clone() const override;
|
|
virtual const svl::SharedString & GetString() const override;
|
|
virtual void SetString( const svl::SharedString& rStr ) override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
|
|
/** Identical to FormulaStringToken, but with explicit OpCode instead of implicit
|
|
ocPush, and an optional sal_uInt8 for ocBad tokens. */
|
|
class FORMULA_DLLPUBLIC FormulaStringOpToken final : public FormulaByteToken
|
|
{
|
|
svl::SharedString maString;
|
|
public:
|
|
FormulaStringOpToken( OpCode e, svl::SharedString r );
|
|
FormulaStringOpToken( const FormulaStringOpToken& r );
|
|
|
|
virtual FormulaToken* Clone() const override;
|
|
virtual const svl::SharedString & GetString() const override;
|
|
virtual void SetString( const svl::SharedString& rStr ) override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
class FORMULA_DLLPUBLIC FormulaIndexToken final : public FormulaToken
|
|
{
|
|
private:
|
|
sal_uInt16 nIndex;
|
|
sal_Int16 mnSheet;
|
|
public:
|
|
FormulaIndexToken( OpCode e, sal_uInt16 n, sal_Int16 nSheet = -1 ) :
|
|
FormulaToken( svIndex, e ), nIndex( n ), mnSheet( nSheet ) {}
|
|
FormulaIndexToken( const FormulaIndexToken& r ) :
|
|
FormulaToken( r ), nIndex( r.nIndex ), mnSheet( r.mnSheet ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaIndexToken(*this); }
|
|
virtual sal_uInt16 GetIndex() const override;
|
|
virtual void SetIndex( sal_uInt16 n ) override;
|
|
virtual sal_Int16 GetSheet() const override;
|
|
virtual void SetSheet( sal_Int16 n ) override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
|
|
class FORMULA_DLLPUBLIC FormulaExternalToken final : public FormulaByteToken
|
|
{
|
|
private:
|
|
OUString aExternal;
|
|
public:
|
|
FormulaExternalToken( OpCode e, sal_uInt8 n, OUString r ) :
|
|
FormulaByteToken( e, n, svExternal, ParamClass::Unknown ),
|
|
aExternal(std::move( r )) {}
|
|
FormulaExternalToken( OpCode e, OUString r ) :
|
|
FormulaByteToken( e, 0, svExternal, ParamClass::Unknown ),
|
|
aExternal(std::move( r )) {}
|
|
FormulaExternalToken( const FormulaExternalToken& r ) :
|
|
FormulaByteToken( r ), aExternal( r.aExternal ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaExternalToken(*this); }
|
|
virtual const OUString& GetExternal() const override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
|
|
class FORMULA_DLLPUBLIC FormulaMissingToken final : public FormulaToken
|
|
{
|
|
public:
|
|
FormulaMissingToken() :
|
|
FormulaToken( svMissing,ocMissing ) {}
|
|
FormulaMissingToken( const FormulaMissingToken& r ) :
|
|
FormulaToken( r ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaMissingToken(*this); }
|
|
virtual double GetDouble() const override;
|
|
virtual const svl::SharedString & GetString() const override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
class FORMULA_DLLPUBLIC FormulaJumpToken final : public FormulaToken
|
|
{
|
|
private:
|
|
std::unique_ptr<short[]>
|
|
pJump;
|
|
ParamClass eInForceArray;
|
|
public:
|
|
FormulaJumpToken( OpCode e, short const * p ) :
|
|
FormulaToken( formula::svJump , e),
|
|
eInForceArray( ParamClass::Unknown)
|
|
{
|
|
pJump.reset( new short[ p[0] + 1 ] );
|
|
memcpy( pJump.get(), p, (p[0] + 1) * sizeof(short) );
|
|
}
|
|
FormulaJumpToken( const FormulaJumpToken& r ) :
|
|
FormulaToken( r ),
|
|
eInForceArray( r.eInForceArray)
|
|
{
|
|
pJump.reset( new short[ r.pJump[0] + 1 ] );
|
|
memcpy( pJump.get(), r.pJump.get(), (r.pJump[0] + 1) * sizeof(short) );
|
|
}
|
|
virtual ~FormulaJumpToken() override;
|
|
virtual short* GetJump() const override;
|
|
virtual bool operator==( const formula::FormulaToken& rToken ) const override;
|
|
virtual FormulaToken* Clone() const override { return new FormulaJumpToken(*this); }
|
|
virtual ParamClass GetInForceArray() const override;
|
|
virtual void SetInForceArray( ParamClass c ) override;
|
|
};
|
|
|
|
|
|
class FORMULA_DLLPUBLIC FormulaUnknownToken final : public FormulaToken
|
|
{
|
|
public:
|
|
FormulaUnknownToken( OpCode e ) :
|
|
FormulaToken( svUnknown, e ) {}
|
|
FormulaUnknownToken( const FormulaUnknownToken& r ) :
|
|
FormulaToken( r ) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaUnknownToken(*this); }
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
|
|
class FORMULA_DLLPUBLIC FormulaErrorToken final : public FormulaToken
|
|
{
|
|
FormulaError nError;
|
|
public:
|
|
FormulaErrorToken( FormulaError nErr ) :
|
|
FormulaToken( svError ), nError( nErr) {}
|
|
FormulaErrorToken( const FormulaErrorToken& r ) :
|
|
FormulaToken( r ), nError( r.nError) {}
|
|
|
|
virtual FormulaToken* Clone() const override { return new FormulaErrorToken(*this); }
|
|
virtual FormulaError GetError() const override;
|
|
virtual void SetError( FormulaError nErr ) override;
|
|
virtual bool operator==( const FormulaToken& rToken ) const override;
|
|
};
|
|
|
|
|
|
} // formula
|
|
|
|
|
|
#endif
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|