QoreValue.h

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    QoreValue.h

    Qore Programming Language

    Copyright (C) 2003 - 2020 Qore Technologies, s.r.o.

    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.

    Note that the Qore library is released under a choice of three open-source
    licenses: MIT (as above), LGPL 2+, or GPL 2+; see README-LICENSE for more
    information.
*/

#ifndef _QORE_QOREVALUE_H
#define _QORE_QOREVALUE_H

#include <cassert>

typedef unsigned char valtype_t;


#define QV_Bool  (valtype_t)0  
#define QV_Int   (valtype_t)1  
#define QV_Float (valtype_t)2  
#define QV_Node  (valtype_t)3  
#define QV_Ref   (valtype_t)4  


// forward references
class AbstractQoreNode;
class QoreString;
hashdecl QoreValue;

union qore_value_u {
    bool b;               
    int64 i;              
    double f;             
    AbstractQoreNode* n;  
};

namespace detail {
    template<typename Type>
    hashdecl QoreValueCastHelper {
        typedef Type * Result;

        template<typename QV>
        static Result cast(QV *qv, valtype_t type) {
            assert(type == QV_Node);
            assert(!qv->v.n || dynamic_cast<Result>(qv->v.n));
            return reinterpret_cast<Result>(qv->v.n);
        }
    };

    template<>
    hashdecl QoreValueCastHelper<bool> {
        typedef bool Result;

        template<typename QV>
        static bool cast(QV *qv, valtype_t type) {
            return qv->getAsBool();
        }
    };

    template<>
    hashdecl QoreValueCastHelper<double> {
        typedef double Result;

        template<typename QV>
        static double cast(QV *qv, valtype_t type) {
            return qv->getAsFloat();
        }
    };

    template<>
    hashdecl QoreValueCastHelper<int64> {
        typedef int64 Result;

        template<typename QV>
        static int64 cast(QV *qv, valtype_t type) {
            return qv->getAsBigInt();
        }
    };
} // namespace detail

class QoreSimpleValue {
public:
    qore_value_u v;
    valtype_t type;

    DLLLOCAL void set(int64 i) {
        type = QV_Int;
        v.i = i;
    }

    DLLLOCAL void set(double f) {
        type = QV_Float;
        v.f = f;
    }

    DLLLOCAL void set(bool b) {
        type = QV_Bool;
        v.b = b;
    }

    DLLEXPORT void set(QoreSimpleValue val);

    DLLEXPORT void set(AbstractQoreNode* n);

    DLLLOCAL QoreSimpleValue& assign(QoreSimpleValue& val) {
        set(val);
        return *this;
    }

    DLLLOCAL QoreSimpleValue& assign(int64 i) {
        set(i);
        return *this;
    }

    DLLLOCAL QoreSimpleValue& assign(double f) {
        set(f);
        return *this;
    }

    DLLLOCAL QoreSimpleValue& assign(bool b) {
        set(b);
        return *this;
    }

    DLLLOCAL QoreSimpleValue& assign(AbstractQoreNode* n) {
        set(n);
        return *this;
    }

    DLLEXPORT qore_type_t getType() const;

    DLLEXPORT const char* getTypeName() const;


    DLLEXPORT AbstractQoreNode* takeNode();

    DLLEXPORT AbstractQoreNode* getInternalNode();

    DLLEXPORT const AbstractQoreNode* getInternalNode() const;

    DLLEXPORT void clear();

    DLLEXPORT void discard(ExceptionSink* xsink);


    template<typename T>
    DLLLOCAL T* take() {
        assert(type == QV_Node);
        assert(dynamic_cast<T*>(v.n));
        T* rv = reinterpret_cast<T*>(v.n);
        v.n = 0;
        return rv;
    }


    template<typename T>
    DLLLOCAL typename detail::QoreValueCastHelper<T>::Result get() {
        return detail::QoreValueCastHelper<T>::cast(this, type);
    }


    template<typename T>
    DLLLOCAL typename detail::QoreValueCastHelper<const T>::Result get() const {
        return detail::QoreValueCastHelper<const T>::cast(this, type);
    }

    DLLEXPORT bool getAsBool() const;

    DLLEXPORT int64 getAsBigInt() const;

    DLLEXPORT double getAsFloat() const;

    DLLEXPORT bool hasEffect() const;

    DLLEXPORT bool isNothing() const;

    DLLEXPORT bool isNull() const;

    DLLEXPORT bool isNullOrNothing() const;

    DLLEXPORT bool isValue() const;

    DLLEXPORT bool needsEval() const;

    DLLEXPORT operator bool() const;

protected:
    DLLEXPORT AbstractQoreNode* takeNodeIntern();
};

hashdecl QoreValue : public QoreSimpleValue {
    friend class ValueHolder;
    friend class ValueOptionalRefHolder;
    template<typename> friend hashdecl detail::QoreValueCastHelper;

public:
    DLLEXPORT QoreValue();

    DLLEXPORT QoreValue(bool b);

    DLLEXPORT QoreValue(int i);

    DLLEXPORT QoreValue(unsigned int i);

    DLLEXPORT QoreValue(long i);

    DLLEXPORT QoreValue(unsigned long i);

    DLLEXPORT QoreValue(unsigned long long i);

    DLLEXPORT QoreValue(int64 i);

    DLLEXPORT QoreValue(double f);

    DLLEXPORT QoreValue(AbstractQoreNode* n);


    DLLEXPORT QoreValue(const AbstractQoreNode* n);

    DLLEXPORT QoreValue(const QoreSimpleValue& v);

    DLLEXPORT QoreValue(const QoreValue& old);

    DLLEXPORT void swap(QoreValue& val);

    DLLEXPORT void ref() const;

    DLLEXPORT QoreValue refSelf() const;


    DLLEXPORT AbstractQoreNode* assign(AbstractQoreNode* n);


    DLLEXPORT AbstractQoreNode* assignAndSanitize(const QoreValue n);


    DLLEXPORT AbstractQoreNode* assign(int64 n);


    DLLEXPORT AbstractQoreNode* assign(double n);


    DLLEXPORT AbstractQoreNode* assign(bool n);


    DLLEXPORT AbstractQoreNode* assignNothing();

    DLLEXPORT bool isEqualSoft(const QoreValue v, ExceptionSink* xsink) const;

    DLLEXPORT bool isEqualHard(const QoreValue v) const;

    DLLEXPORT bool isEqualValue(const QoreValue v);

    DLLEXPORT void sanitize();

    DLLEXPORT QoreValue& operator=(const QoreValue& n);

    DLLEXPORT QoreValue& operator=(const QoreSimpleValue& n);

    DLLEXPORT void discard(ExceptionSink* xsink);

    DLLEXPORT int getAsString(QoreString& str, int format_offset, ExceptionSink *xsink) const;

    DLLEXPORT QoreString* getAsString(bool& del, int foff, ExceptionSink* xsink) const;

    DLLEXPORT QoreValue eval(ExceptionSink* xsink) const;

    DLLEXPORT QoreValue eval(bool& needs_deref, ExceptionSink* xsink) const;

    //DLLEXPORT QoreValue refSelf() const;

    DLLEXPORT AbstractQoreNode* takeIfNode();


    DLLEXPORT const QoreTypeInfo* getTypeInfo() const;


    DLLEXPORT const QoreTypeInfo* getFullTypeInfo() const;

    DLLEXPORT const char* getFullTypeName() const;

    DLLEXPORT bool hasNode() const;

    DLLEXPORT bool isReferenceCounted() const;

    DLLEXPORT bool derefCanThrowException() const;
};

class ValueHolderBase {
protected:
    QoreValue v;
    ExceptionSink* xsink;

public:
    DLLLOCAL ValueHolderBase(ExceptionSink* xs) : xsink(xs) {
    }

    DLLLOCAL ValueHolderBase(QoreValue n_v, ExceptionSink* xs) : v(n_v), xsink(xs) {
    }

    DLLLOCAL QoreValue* operator->() { return &v; }

    DLLLOCAL const QoreValue* operator->() const { return &v; }

    DLLLOCAL QoreValue& operator*() { return v; }

    DLLLOCAL const QoreValue& operator*() const { return v; }
};

class ValueHolder : public ValueHolderBase {
public:
    DLLLOCAL ValueHolder(ExceptionSink* xs) : ValueHolderBase(xs) {
    }

    DLLLOCAL ValueHolder(QoreValue n_v, ExceptionSink* xs) : ValueHolderBase(n_v, xs) {
    }

    DLLEXPORT ~ValueHolder();

    DLLEXPORT QoreValue getReferencedValue();

    DLLEXPORT QoreValue release();

    DLLLOCAL QoreValue& operator=(QoreValue nv) {
        v.discard(xsink);
        v = nv;
        return v;
    }

    DLLLOCAL operator bool() const {
        return (bool)v;
    }
};

class ValueOptionalRefHolder : public ValueHolderBase {
private:
    // not implemented
    DLLLOCAL QoreValue& operator=(QoreValue& nv);

protected:
    bool needs_deref;

public:
    DLLLOCAL ValueOptionalRefHolder(QoreValue n_v, bool nd, ExceptionSink* xs) : ValueHolderBase(n_v, xs), needs_deref(nd) {
    }

    DLLLOCAL ValueOptionalRefHolder(ExceptionSink* xs) : ValueHolderBase(xs), needs_deref(false) {
    }

    DLLEXPORT ~ValueOptionalRefHolder();

    DLLLOCAL bool isTemp() const { return needs_deref; }

    DLLLOCAL void clearTemp() {
        if (needs_deref)
            needs_deref = false;
    }

    DLLLOCAL operator bool() const {
        return (bool)v;
    }

    DLLLOCAL void setValue(QoreValue nv) {
        if (needs_deref) {
            v.discard(xsink);
            needs_deref = false;
        }
        v = nv;
    }

    DLLLOCAL void setValue(QoreValue nv, bool temp) {
        if (needs_deref)
            v.discard(xsink);
        if (needs_deref != temp)
            needs_deref = temp;
        v = nv;
    }

    // ensures that the held value is referenced
    DLLEXPORT void ensureReferencedValue();

    template<typename T>
    DLLLOCAL T* takeReferencedNode() {
        T* rv = v.take<T>();
        if (needs_deref)
            needs_deref = false;
        else
            rv->ref();

        return rv;
    }

    DLLEXPORT QoreValue getReferencedValue();

    DLLLOCAL AbstractQoreNode* takeNode(bool& nd) {
        if (v.type == QV_Node) {
            nd = needs_deref;
            return v.takeNodeIntern();
        }
        nd = true;
        return v.takeNode();
    }

    DLLLOCAL QoreValue takeValue(bool& nd) {
        if (v.type == QV_Node) {
            nd = needs_deref;
            return v.takeNodeIntern();
        }
        nd = false;
        return v;
    }

    DLLLOCAL void takeValueFrom(ValueOptionalRefHolder& val) {
        if (needs_deref)
            v.discard(xsink);
        v = val.takeValue(needs_deref);
    }

    DLLEXPORT QoreValue takeReferencedValue();

    // FIXME: remove with new API/ABI
    DLLLOCAL void sanitize();
};

class ValueEvalRefHolder : public ValueOptionalRefHolder {
public:
    DLLEXPORT ValueEvalRefHolder(const AbstractQoreNode* exp, ExceptionSink* xs);


    DLLEXPORT ValueEvalRefHolder(const QoreValue exp, ExceptionSink* xs);


    DLLEXPORT ValueEvalRefHolder(ExceptionSink* xs);


    DLLEXPORT int eval(const AbstractQoreNode* exp);


    DLLEXPORT int eval(const QoreValue exp);

protected:

    DLLLOCAL int evalIntern(const AbstractQoreNode* exp);


    DLLLOCAL int evalIntern(const QoreValue exp);
};

DLLEXPORT extern const char* qoreBoolTypeName;
DLLEXPORT extern const char* qoreIntTypeName;
DLLEXPORT extern const char* qoreFloatTypeName;

#endif