/* -*- 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 .

 */

#pragma once

#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 <formula/errorcodes.hxx>

#include <formula/callable.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;

namespace formula

{

enum StackVar : sal_uInt8

{

    svByte,

    svDouble,

    svString,

    svStringName,

    svCallable,

    svDPFieldName,

    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 svStringName:        return "StringName";

        case svCallable:          return "Callable";

        case svDPFieldName:       return "DPFieldName";

        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 ParamClass          GetInForceArray() const;

    virtual void                SetInForceArray( ParamClass c );

    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); }

    sal_uInt8                   GetByte() const;

    sal_Unicode                 GetChar() const;

    virtual bool                operator==( const FormulaToken& rToken ) const override;

};

class FORMULA_DLLPUBLIC FormulaByteToken final : public FormulaToken

{

private:

            sal_uInt8           mnByte;

            ParamClass          eInForceArray;

public:

                                FormulaByteToken( OpCode e, sal_uInt8 n, ParamClass c ) :

                                    FormulaToken( svByte,e ), mnByte( n ),

                                    eInForceArray( c ) {}

                                FormulaByteToken( OpCode e, sal_uInt8 n ) :

                                    FormulaToken( svByte,e ), mnByte( n ),

                                    eInForceArray( ParamClass::Unknown ) {}

                                FormulaByteToken( OpCode e ) :

                                    FormulaToken( svByte,e ), mnByte( 0 ),

                                    eInForceArray( ParamClass::Unknown ) {}

                                FormulaByteToken( const FormulaByteToken& r ) :

                                    FormulaToken( r ), mnByte( r.mnByte ),

                                    eInForceArray( r.eInForceArray ) {}

    virtual FormulaToken*       Clone() const override { return new FormulaByteToken(*this); }

    sal_uInt8                   GetByte() const { return mnByte; }

    void                        SetByte( sal_uInt8 n ) { mnByte = n; }

    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 FormulaToken

{

private:

            sal_uInt8           mnByte;

            FormulaTokenRef     pOrigToken;

public:

                                FormulaFAPToken( OpCode e, sal_uInt8 n, FormulaToken* p ) :

                                    FormulaToken(svFAP, e), mnByte(n), pOrigToken( p ) {}

                                FormulaFAPToken( const FormulaFAPToken& r ) :

                                    FormulaToken( r ), mnByte(r.mnByte), pOrigToken( r.pOrigToken ) {}

    virtual FormulaToken*       Clone() const override { return new FormulaFAPToken(*this); }

    FormulaToken*               GetFAPOrigToken() const;

    sal_uInt8                   GetByte() const { return mnByte; }

    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); }

    double                      GetDouble() const { return fDouble; }

    void                        SetDouble(double fValue) { fDouble = fValue; }

    virtual sal_Int16           GetDoubleType() const;     ///< 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;

    void                        SetDoubleType( sal_Int16 nType );

    virtual bool                operator==( const FormulaToken& rToken ) const override;

};

class FORMULA_DLLPUBLIC FormulaStringToken : public FormulaToken

{

    svl::SharedString maString;

protected:

    // constructor for FormulaStringOpToken to use

    FormulaStringToken( OpCode e, svl::SharedString r );

public:

    FormulaStringToken( svl::SharedString r );

    FormulaStringToken( const FormulaStringToken& r );

    virtual FormulaToken* Clone() const override;

    const svl::SharedString & GetString() const { return maString; }

    void SetString( const svl::SharedString& rStr );

    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 FormulaStringToken

{

    sal_uInt8           nByte;

    ParamClass          eInForceArray;

public:

    FormulaStringOpToken( OpCode e, svl::SharedString r );

    FormulaStringOpToken( const FormulaStringOpToken& r );

    virtual FormulaToken* Clone() const override;

    sal_uInt8                   GetByte() const { return nByte; }

    void                        SetByte( sal_uInt8 n ) { nByte = n; }

    virtual ParamClass          GetInForceArray() const override final { return eInForceArray; }

    virtual void                SetInForceArray( ParamClass c ) override final { eInForceArray = c; }

    virtual bool operator==( const FormulaToken& rToken ) const override;

};

// FormulaStringNameToken

class FORMULA_DLLPUBLIC FormulaStringNameToken final : public FormulaToken

{

    svl::SharedString maString;

    bool mIsOptional;

public:

    FormulaStringNameToken(StackVar eTypeP, svl::SharedString r, bool isOptional = false);

    FormulaStringNameToken(const FormulaStringNameToken& r);

    virtual FormulaToken* Clone() const override;

    const svl::SharedString& GetString() const { return maString; }

    bool GetIsOptional() const { return mIsOptional; }

    void SetIsOptional(bool isOptional) { mIsOptional = isOptional; }

    virtual bool operator==(const FormulaToken& rToken) const override;

};

// A data-pilot field name is stored in a FormulaStringNameToken too, so both

// svStringName and svDPFieldName identify one.

inline const FormulaStringNameToken* GetStringNameToken(const FormulaToken* p)

{

    const StackVar eType = p->GetType();

    if (eType == svStringName || eType == svDPFieldName)

    {

        assert(dynamic_cast<const FormulaStringNameToken*>(p));

        return static_cast<const FormulaStringNameToken*>(p);

    }

    return nullptr;

}

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); }

    sal_uInt16                  GetIndex() const;

    void                        SetIndex( sal_uInt16 n );

    sal_Int16                   GetSheet() const;

    void                        SetSheet( sal_Int16 n );

    virtual bool                operator==( const FormulaToken& rToken ) const override;

};

class FORMULA_DLLPUBLIC FormulaExternalToken final : public FormulaToken

{

private:

    sal_uInt8         mnByte;

    ParamClass        eInForceArray;

    OUString          aExternal;

public:

                                FormulaExternalToken( OpCode e, sal_uInt8 n, OUString  r ) :

                                    FormulaToken( svExternal, e), mnByte(n), eInForceArray( ParamClass::Unknown ),

                                    aExternal(std::move( r )) {}

                                FormulaExternalToken( OpCode e, OUString  r ) :

                                    FormulaToken( svExternal, e), mnByte(0), eInForceArray( ParamClass::Unknown ),

                                    aExternal(std::move( r )) {}

                                FormulaExternalToken( const FormulaExternalToken& r ) :

                                    FormulaToken( r ), mnByte(r.mnByte), eInForceArray(r.eInForceArray), aExternal( r.aExternal ) {}

    virtual FormulaToken*       Clone() const override { return new FormulaExternalToken(*this); }

    const OUString&             GetExternal() const;

    sal_uInt8                   GetByte() const { return mnByte; }

    void                        SetByte( sal_uInt8 n ) { mnByte = n; }

    virtual ParamClass          GetInForceArray() const override final { return eInForceArray; }

    virtual void                SetInForceArray( ParamClass c ) override final { eInForceArray = c; }

    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 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;

    const short*                GetJump() const { return pJump.get(); }

    short*                      GetJump() { return pJump.get(); }

    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() :

                                    FormulaToken( svError ), nError( FormulaError::IllegalChar ) {}

                                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); }

    FormulaError                GetError() const;

    void                        SetError( FormulaError nErr );

    virtual bool                operator==( const FormulaToken& rToken ) const override;

    // we do some performance stuff in ScInterpreter::PushError that needs this

    FormulaErrorToken& operator=( const FormulaErrorToken& rOther )

    {

        nError = rOther.nError;

        return *this;

    }

};

// Only created from within the interpreter

class FORMULA_DLLPUBLIC FormulaCallableToken final : public FormulaToken

{

private:

            FormulaCallableRef  mpCallable;

public:

                                FormulaCallableToken( FormulaCallableRef pCallable ) :

                                    FormulaToken( svCallable ), mpCallable(pCallable) {}

                                FormulaCallableToken( const FormulaCallableToken& r ) = default;

    virtual FormulaToken*       Clone() const override { return new FormulaCallableToken(*this); }

            FormulaCallableRef  GetCallable() const;

    virtual bool                operator==( const FormulaToken& rToken ) const override;

};

} // formula

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */