QoreValue.h

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    QoreValue.h
 
    Qore Programming Language
 
    Copyright (C) 2003 - 2023 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(const QoreSimpleValue& val);
 
    DLLEXPORT void set(AbstractQoreNode* n);
 
    DLLLOCAL QoreSimpleValue& assign(const 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 isEqualHard(const QoreValue v) const;
 
    DLLEXPORT bool isNothing() const;
 
    DLLEXPORT bool isNull() const;
 
    DLLEXPORT bool isNullOrNothing() const;
 
    DLLEXPORT bool isValue() const;
 
    DLLEXPORT bool needsEval() const;
 
 
    DLLEXPORT bool isScalar() const;
 
 
    DLLEXPORT bool isConstant() 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(const QoreValue n);
 
 
    DLLEXPORT AbstractQoreNode* assign(AbstractQoreNode* 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 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 const char* getFullTypeName(bool with_namespaces) const;
 
 
    DLLEXPORT const char* getFullTypeName(bool with_namespaces, QoreString& scratch) 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();
 
 
    template<typename T>
    DLLLOCAL T* releaseAs() {
        T* rv = v.get<T>();
        release();
        return rv;
    }
 
    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();
};
 
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);
};
 
class ValueEvalOptimizedRefHolder : public ValueEvalRefHolder {
public:
    DLLEXPORT ValueEvalOptimizedRefHolder(const QoreValue& exp, ExceptionSink* xs);
 
    DLLEXPORT ValueEvalOptimizedRefHolder(ExceptionSink* xs);
 
    DLLEXPORT int eval(const QoreValue& exp);
};
 
DLLEXPORT extern const char* qoreBoolTypeName;
DLLEXPORT extern const char* qoreIntTypeName;
DLLEXPORT extern const char* qoreFloatTypeName;
 
#endif