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