include/formula/token.hxx

   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 #ifndef INCLUDED_FORMULA_TOKEN_HXX
  21 #define INCLUDED_FORMULA_TOKEN_HXX
  22
  23 #include <sal/config.h>
  24
  25 #include <cstring>
  26 #include <memory>
  27 #include <vector>
  28
  29 #include <formula/formuladllapi.h>
  30 #include <formula/opcode.hxx>
  31 #include <formula/types.hxx>
  32 #include <formula/paramclass.hxx>
  33 #include <osl/interlck.h>
  34 #include <rtl/ustring.hxx>
  35 #include <sal/types.h>
  36 #include <svl/sharedstring.hxx>
  37
  38 class ScJumpMatrix;
  39 class ScMatrix;
  40 struct ScComplexRefData;
  41 struct ScSingleRefData;
  42 enum class FormulaError : sal_uInt16;
  43
  44 namespace formula
  45 {
  46
  47 enum StackVar : sal_uInt8
  48 {
  49     svByte,
  50     svDouble,
  51     svString,
  52     svSingleRef,
  53     svDoubleRef,
  54     svMatrix,
  55     svIndex,
  56     svJump,
  57     svExternal,                         // Byte + String
  58     svFAP,                              // FormulaAutoPilot only, ever exported
  59     svJumpMatrix,
  60     svRefList,                          // ocUnion result
  61     svEmptyCell,                        // Result is an empty cell, e.g. in LOOKUP()
  62
  63     svMatrixCell,                       // Result is a matrix with bells and
  64                                         // whistles as needed for _the_ matrix
  65                                         // formula result.
  66
  67     svHybridCell,                       // A temporary condition of a formula
  68                                         // cell during import, having a double
  69                                         // and/or string result and a formula
  70                                         // string to be compiled.
  71
  72     svExternalSingleRef,
  73     svExternalDoubleRef,
  74     svExternalName,
  75     svSingleVectorRef,
  76     svDoubleVectorRef,
  77     svError,                            // error token
  78     svMissing,                          // 0 or ""
  79     svSep,                              // separator, ocSep, ocOpen, ocClose
  80     svUnknown                           // unknown StackType
  81 };
  82
  83 // Only to be used for debugging output. No guarantee of stability of the
  84 // return value.
  85
  86 // Turn this into an operator<< when StackVar becomes a scoped enum
  87
  88 inline std::string StackVarEnumToString(StackVar const e)
  89 {
  90     switch (e)
  91     {
  92         case svByte:              return "Byte";
  93         case svDouble:            return "Double";
  94         case svString:            return "String";
  95         case svSingleRef:         return "SingleRef";
  96         case svDoubleRef:         return "DoubleRef";
  97         case svMatrix:            return "Matrix";
  98         case svIndex:             return "Index";
  99         case svJump:              return "Jump";
 100         case svExternal:          return "External";
 101         case svFAP:               return "FAP";
 102         case svJumpMatrix:        return "JumpMatrix";
 103         case svRefList:           return "RefList";
 104         case svEmptyCell:         return "EmptyCell";
 105         case svMatrixCell:        return "MatrixCell";
 106         case svHybridCell:        return "HybridCell";
 107         case svExternalSingleRef: return "ExternalSingleRef";
 108         case svExternalDoubleRef: return "ExternalDoubleRef";
 109         case svExternalName:      return "ExternalName";
 110         case svSingleVectorRef:   return "SingleVectorRef";
 111         case svDoubleVectorRef:   return "DoubleVectorRef";
 112         case svError:             return "Error";
 113         case svMissing:           return "Missing";
 114         case svSep:               return "Sep";
 115         case svUnknown:           return "Unknown";
 116     }
 117     std::ostringstream os;
 118     os << static_cast<int>(e);
 119     return os.str();
 120 }
 121
 122 class FORMULA_DLLPUBLIC FormulaToken
 123 {
 124     OpCode                      eOp;
 125     const StackVar              eType;          // type of data
 126     mutable oslInterlockedCount mnRefCnt;        // reference count
 127
 128     FormulaToken&            operator=( const FormulaToken& ) = delete;
 129 public:
 130     FormulaToken( StackVar eTypeP,OpCode e = ocPush );
 131     FormulaToken( const FormulaToken& r );
 132
 133     virtual                     ~FormulaToken();
 134
 135     void                Delete()                { delete this; }
 136     void                DeleteIfZeroRef()       { if (mnRefCnt == 0) delete this; }
 137     StackVar            GetType() const         { return eType; }
 138     bool                IsFunction() const; // pure functions, no operators
 139
 140     bool IsExternalRef() const;
 141     bool IsRef() const;
 142
 143             sal_uInt8           GetParamCount() const;
 144
 145     void IncRef() const
 146     {
 147         osl_atomic_increment(&mnRefCnt);
 148     }
 149
 150     void DecRef() const
 151     {
 152         if (!osl_atomic_decrement(&mnRefCnt))
 153             const_cast<FormulaToken*>(this)->Delete();
 154     }
 155
 156     oslInterlockedCount GetRef() const       { return mnRefCnt; }
 157     OpCode              GetOpCode() const    { return eOp; }
 158
 159     bool                IsInForceArray() const;
 160
 161     /**
 162         Dummy methods to avoid switches and casts where possible,
 163         the real token classes have to override the appropriate method[s].
 164         The only methods valid anytime if not overridden are:
 165
 166         - GetByte() since this represents the count of parameters to a function
 167           which of course is 0 on non-functions. FormulaByteToken and ScExternal do
 168           override it.
 169
 170         - GetInForceArray() since also this is only used for operators and
 171           functions and is ParamClass::Unknown for other tokens.
 172
 173         Any other non-overridden method pops up an assertion.
 174      */
 175
 176     virtual sal_uInt8           GetByte() const;
 177     virtual void                SetByte( sal_uInt8 n );
 178     virtual ParamClass          GetInForceArray() const;
 179     virtual void                SetInForceArray( ParamClass c );
 180     virtual double              GetDouble() const;
 181     virtual double&             GetDoubleAsReference();
 182     virtual sal_Int16           GetDoubleType() const;
 183     virtual void                SetDoubleType( sal_Int16 nType );
 184     virtual svl::SharedString   GetString() const;
 185     virtual void                SetString( const svl::SharedString& rStr );
 186     virtual sal_uInt16          GetIndex() const;
 187     virtual void                SetIndex( sal_uInt16 n );
 188     virtual sal_Int16           GetSheet() const;
 189     virtual void                SetSheet( sal_Int16 n );
 190     virtual short*              GetJump() const;
 191     virtual const OUString&     GetExternal() const;
 192     virtual FormulaToken*       GetFAPOrigToken() const;
 193     virtual FormulaError        GetError() const;
 194     virtual void                SetError( FormulaError );
 195
 196     virtual const ScSingleRefData*  GetSingleRef() const;
 197     virtual ScSingleRefData*        GetSingleRef();
 198     virtual const ScComplexRefData* GetDoubleRef() const;
 199     virtual ScComplexRefData*       GetDoubleRef();
 200     virtual const ScSingleRefData*  GetSingleRef2() const;
 201     virtual ScSingleRefData*        GetSingleRef2();
 202     virtual const ScMatrix*     GetMatrix() const;
 203     virtual ScMatrix*           GetMatrix();
 204     virtual ScJumpMatrix*       GetJumpMatrix() const;
 205     virtual const std::vector<ScComplexRefData>* GetRefList() const;
 206     virtual       std::vector<ScComplexRefData>* GetRefList();
 207
 208     virtual FormulaToken*       Clone() const { return new FormulaToken(*this); }
 209
 210     virtual bool                TextEqual( const formula::FormulaToken& rToken ) const;
 211     virtual bool                operator==( const FormulaToken& rToken ) const;
 212
 213     /** This is dirty and only the compiler should use it! */
 214     struct PrivateAccess { friend class FormulaCompiler; private: PrivateAccess() { }  };
 215     void                NewOpCode( OpCode e, const PrivateAccess&  ) { eOp = e; }
 216 };
 217
 218 inline void intrusive_ptr_add_ref(const FormulaToken* p)
 219 {
 220     p->IncRef();
 221 }
 222
 223 inline void intrusive_ptr_release(const FormulaToken* p)
 224 {
 225     p->DecRef();
 226 }
 227
 228 class FORMULA_DLLPUBLIC FormulaByteToken : public FormulaToken
 229 {
 230 private:
 231             sal_uInt8           nByte;
 232             ParamClass          eInForceArray;
 233 protected:
 234                                 FormulaByteToken( OpCode e, sal_uInt8 n, StackVar v, ParamClass c ) :
 235                                     FormulaToken( v,e ), nByte( n ),
 236                                     eInForceArray( c ) {}
 237 public:
 238                                 FormulaByteToken( OpCode e, sal_uInt8 n, ParamClass c ) :
 239                                     FormulaToken( svByte,e ), nByte( n ),
 240                                     eInForceArray( c ) {}
 241                                 FormulaByteToken( OpCode e, sal_uInt8 n ) :
 242                                     FormulaToken( svByte,e ), nByte( n ),
 243                                     eInForceArray( ParamClass::Unknown ) {}
 244                                 FormulaByteToken( OpCode e ) :
 245                                     FormulaToken( svByte,e ), nByte( 0 ),
 246                                     eInForceArray( ParamClass::Unknown ) {}
 247                                 FormulaByteToken( const FormulaByteToken& r ) :
 248                                     FormulaToken( r ), nByte( r.nByte ),
 249                                     eInForceArray( r.eInForceArray ) {}
 250
 251     virtual FormulaToken*       Clone() const override { return new FormulaByteToken(*this); }
 252     virtual sal_uInt8           GetByte() const override;
 253     virtual void                SetByte( sal_uInt8 n ) override;
 254     virtual ParamClass          GetInForceArray() const override;
 255     virtual void                SetInForceArray( ParamClass c ) override;
 256     virtual bool                operator==( const FormulaToken& rToken ) const override;
 257 };
 258
 259
 260 // A special token for the FormulaAutoPilot only. Keeps a reference pointer of
 261 // the token of which it was created for comparison.
 262 class FORMULA_DLLPUBLIC FormulaFAPToken final : public FormulaByteToken
 263 {
 264 private:
 265             FormulaTokenRef     pOrigToken;
 266 public:
 267                                 FormulaFAPToken( OpCode e, sal_uInt8 n, FormulaToken* p ) :
 268                                     FormulaByteToken( e, n, svFAP, ParamClass::Unknown ),
 269                                     pOrigToken( p ) {}
 270                                 FormulaFAPToken( const FormulaFAPToken& r ) :
 271                                     FormulaByteToken( r ), pOrigToken( r.pOrigToken ) {}
 272
 273     virtual FormulaToken*       Clone() const override { return new FormulaFAPToken(*this); }
 274     virtual FormulaToken*       GetFAPOrigToken() const override;
 275     virtual bool                operator==( const FormulaToken& rToken ) const override;
 276 };
 277
 278 class FORMULA_DLLPUBLIC FormulaDoubleToken : public FormulaToken
 279 {
 280 private:
 281             double              fDouble;
 282 public:
 283                                 FormulaDoubleToken( double f ) :
 284                                     FormulaToken( svDouble ), fDouble( f ) {}
 285                                 FormulaDoubleToken( const FormulaDoubleToken& r ) :
 286                                     FormulaToken( r ), fDouble( r.fDouble ) {}
 287
 288     virtual FormulaToken*       Clone() const override { return new FormulaDoubleToken(*this); }
 289     virtual double              GetDouble() const override;
 290     virtual double&             GetDoubleAsReference() override;
 291     virtual sal_Int16           GetDoubleType() const override;     ///< always returns 0 for "not typed"
 292     virtual bool                operator==( const FormulaToken& rToken ) const override;
 293 };
 294
 295 class FORMULA_DLLPUBLIC FormulaTypedDoubleToken final : public FormulaDoubleToken
 296 {
 297 private:
 298             sal_Int16           mnType;     /**< Can hold, for example, a value
 299                                               of SvNumFormatType, or by
 300                                               contract any other
 301                                               classification. */
 302 public:
 303                                 FormulaTypedDoubleToken( double f, sal_Int16 nType ) :
 304                                     FormulaDoubleToken( f ), mnType( nType ) {}
 305                                 FormulaTypedDoubleToken( const FormulaTypedDoubleToken& r ) :
 306                                     FormulaDoubleToken( r ), mnType( r.mnType ) {}
 307
 308     virtual FormulaToken*       Clone() const override { return new FormulaTypedDoubleToken(*this); }
 309     virtual sal_Int16           GetDoubleType() const override;
 310     virtual void                SetDoubleType( sal_Int16 nType ) override;
 311     virtual bool                operator==( const FormulaToken& rToken ) const override;
 312 };
 313
 314
 315 class FORMULA_DLLPUBLIC FormulaStringToken final : public FormulaToken
 316 {
 317     svl::SharedString maString;
 318 public:
 319     FormulaStringToken( const svl::SharedString& r );
 320     FormulaStringToken( const FormulaStringToken& r );
 321
 322     virtual FormulaToken* Clone() const override;
 323     virtual svl::SharedString GetString() const override;
 324     virtual void SetString( const svl::SharedString& rStr ) override;
 325     virtual bool operator==( const FormulaToken& rToken ) const override;
 326 };
 327
 328
 329 /** Identical to FormulaStringToken, but with explicit OpCode instead of implicit
 330     ocPush, and an optional sal_uInt8 for ocBad tokens. */
 331 class FORMULA_DLLPUBLIC FormulaStringOpToken final : public FormulaByteToken
 332 {
 333     svl::SharedString maString;
 334 public:
 335     FormulaStringOpToken( OpCode e, const svl::SharedString& r );
 336     FormulaStringOpToken( const FormulaStringOpToken& r );
 337
 338     virtual FormulaToken* Clone() const override;
 339     virtual svl::SharedString GetString() const override;
 340     virtual void SetString( const svl::SharedString& rStr ) override;
 341     virtual bool operator==( const FormulaToken& rToken ) const override;
 342 };
 343
 344 class FORMULA_DLLPUBLIC FormulaIndexToken final : public FormulaToken
 345 {
 346 private:
 347             sal_uInt16          nIndex;
 348             sal_Int16           mnSheet;
 349 public:
 350                                 FormulaIndexToken( OpCode e, sal_uInt16 n, sal_Int16 nSheet = -1 ) :
 351                                     FormulaToken(  svIndex, e ), nIndex( n ), mnSheet( nSheet ) {}
 352                                 FormulaIndexToken( const FormulaIndexToken& r ) :
 353                                     FormulaToken( r ), nIndex( r.nIndex ), mnSheet( r.mnSheet ) {}
 354
 355     virtual FormulaToken*       Clone() const override { return new FormulaIndexToken(*this); }
 356     virtual sal_uInt16          GetIndex() const override;
 357     virtual void                SetIndex( sal_uInt16 n ) override;
 358     virtual sal_Int16           GetSheet() const override;
 359     virtual void                SetSheet( sal_Int16 n ) override;
 360     virtual bool                operator==( const FormulaToken& rToken ) const override;
 361 };
 362
 363
 364 class FORMULA_DLLPUBLIC FormulaExternalToken final : public FormulaToken
 365 {
 366 private:
 367             OUString              aExternal;
 368             sal_uInt8           nByte;
 369 public:
 370                                 FormulaExternalToken( OpCode e, sal_uInt8 n, const OUString& r ) :
 371                                     FormulaToken( svExternal, e ), aExternal( r ),
 372                                     nByte( n ) {}
 373                                 FormulaExternalToken( OpCode e, const OUString& r ) :
 374                                     FormulaToken(svExternal, e ), aExternal( r ),
 375                                     nByte( 0 ) {}
 376                                 FormulaExternalToken( const FormulaExternalToken& r ) :
 377                                     FormulaToken( r ), aExternal( r.aExternal ),
 378                                     nByte( r.nByte ) {}
 379
 380     virtual FormulaToken*       Clone() const override { return new FormulaExternalToken(*this); }
 381     virtual const OUString&       GetExternal() const override;
 382     virtual sal_uInt8           GetByte() const override;
 383     virtual void                SetByte( sal_uInt8 n ) override;
 384     virtual bool                operator==( const FormulaToken& rToken ) const override;
 385 };
 386
 387
 388 class FORMULA_DLLPUBLIC FormulaMissingToken final : public FormulaToken
 389 {
 390 public:
 391                                 FormulaMissingToken() :
 392                                     FormulaToken( svMissing,ocMissing ) {}
 393                                 FormulaMissingToken( const FormulaMissingToken& r ) :
 394                                     FormulaToken( r ) {}
 395
 396     virtual FormulaToken*       Clone() const override { return new FormulaMissingToken(*this); }
 397     virtual double              GetDouble() const override;
 398     virtual svl::SharedString GetString() const override;
 399     virtual bool                operator==( const FormulaToken& rToken ) const override;
 400 };
 401
 402 class FORMULA_DLLPUBLIC FormulaJumpToken final : public FormulaToken
 403 {
 404 private:
 405             std::unique_ptr<short[]>
 406                                 pJump;
 407             ParamClass          eInForceArray;
 408 public:
 409                                 FormulaJumpToken( OpCode e, short const * p ) :
 410                                     FormulaToken( formula::svJump , e),
 411                                     eInForceArray( ParamClass::Unknown)
 412                                 {
 413                                     pJump.reset( new short[ p[0] + 1 ] );
 414                                     memcpy( pJump.get(), p, (p[0] + 1) * sizeof(short) );
 415                                 }
 416                                 FormulaJumpToken( const FormulaJumpToken& r ) :
 417                                     FormulaToken( r ),
 418                                     eInForceArray( r.eInForceArray)
 419                                 {
 420                                     pJump.reset( new short[ r.pJump[0] + 1 ] );
 421                                     memcpy( pJump.get(), r.pJump.get(), (r.pJump[0] + 1) * sizeof(short) );
 422                                 }
 423     virtual                     ~FormulaJumpToken() override;
 424     virtual short*              GetJump() const override;
 425     virtual bool                operator==( const formula::FormulaToken& rToken ) const override;
 426     virtual FormulaToken*       Clone() const override { return new FormulaJumpToken(*this); }
 427     virtual ParamClass          GetInForceArray() const override;
 428     virtual void                SetInForceArray( ParamClass c ) override;
 429 };
 430
 431
 432 class FORMULA_DLLPUBLIC FormulaUnknownToken final : public FormulaToken
 433 {
 434 public:
 435                                 FormulaUnknownToken( OpCode e ) :
 436                                     FormulaToken( svUnknown, e ) {}
 437                                 FormulaUnknownToken( const FormulaUnknownToken& r ) :
 438                                     FormulaToken( r ) {}
 439
 440     virtual FormulaToken*       Clone() const override { return new FormulaUnknownToken(*this); }
 441     virtual bool                operator==( const FormulaToken& rToken ) const override;
 442 };
 443
 444
 445 class FORMULA_DLLPUBLIC FormulaErrorToken final : public FormulaToken
 446 {
 447          FormulaError          nError;
 448 public:
 449                                 FormulaErrorToken( FormulaError nErr ) :
 450                                     FormulaToken( svError ), nError( nErr) {}
 451                                 FormulaErrorToken( const FormulaErrorToken& r ) :
 452                                     FormulaToken( r ), nError( r.nError) {}
 453
 454     virtual FormulaToken*       Clone() const override { return new FormulaErrorToken(*this); }
 455     virtual FormulaError        GetError() const override;
 456     virtual void                SetError( FormulaError nErr ) override;
 457     virtual bool                operator==( const FormulaToken& rToken ) const override;
 458 };
 459
 460
 461 } // formula
 462
 463
 464 #endif
 465
 466 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */