value.hh

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <climits>
#include <functional>
#include <ranges>
#include <span>
 
#include "lix/libexpr/gc-alloc.hh"
#include "lix/libexpr/symbol-table.hh"
#include "lix/libexpr/value/context.hh"
#include "lix/libutil/source-path.hh"
#include "lix/libexpr/print-options.hh"
#include "lix/libutil/checked-arithmetic.hh"
#include "lix/libutil/concepts.hh"
#include "lix/libutil/json-fwd.hh"
 
namespace nix {
 
class BindingsBuilder;
 
 
typedef enum {
    tInt = 1,
    tBool,
    tString,
    tPath,
    tNull,
    tAttrs,
    tList1,
    tList2,
    tListN,
    tThunk,
    tApp,
    tLambda,
    tPrimOp,
    tPrimOpApp,
    tExternal,
    tFloat
} InternalType;

typedef enum {
    nThunk,
    nInt,
    nFloat,
    nBool,
    nString,
    nPath,
    nNull,
    nAttrs,
    nList,
    nFunction,
    nExternal
} ValueType;
 
class Bindings;
struct Env;
struct Expr;
struct ExprLambda;
struct ExprBlackHole;
struct PrimOp;
class Symbol;
class PosIdx;
struct Pos;
class StorePath;
class Store;
class EvalState;
class XMLWriter;
class Printer;
 
using NixInt = checked::Checked<int64_t>;
using NixFloat = double;

class ExternalValueBase
{
    friend std::ostream & operator << (std::ostream & str, const ExternalValueBase & v);
    friend class Printer;
    protected:
    virtual std::ostream & print(std::ostream & str) const = 0;
 
    public:
    virtual std::string showType() const = 0;

    virtual std::string typeOf() const = 0;

    virtual std::string coerceToString(EvalState & state, const PosIdx & pos, NixStringContext & context, bool copyMore, bool copyToStore) const;

    virtual bool operator ==(const ExternalValueBase & b) const;

    virtual JSON printValueAsJSON(EvalState & state, bool strict,
        NixStringContext & context, bool copyToStore = true) const;

    virtual void printValueAsXML(EvalState & state, bool strict, bool location,
        XMLWriter & doc, NixStringContext & context, PathSet & drvsSeen,
        const PosIdx pos) const;
 
    virtual ~ExternalValueBase()
    {
    };
};
 
std::ostream & operator << (std::ostream & str, const ExternalValueBase & v);

extern Expr *eBlackHoleAddr;
 
struct NewValueAs
{
    struct integer_t { };
    constexpr static integer_t integer{};
 
    struct floating_t { };
    constexpr static floating_t floating{};
 
    struct boolean_t { };
    constexpr static boolean_t boolean{};
 
    struct string_t { };
    constexpr static string_t string{};
 
    struct path_t { };
    constexpr static path_t path{};
 
    struct list_t { };
    constexpr static list_t list{};
 
    struct attrs_t { };
    constexpr static attrs_t attrs{};
 
    struct thunk_t { };
    constexpr static thunk_t thunk{};
 
    struct null_t { };
    constexpr static null_t null{};
 
    struct app_t { };
    constexpr static app_t app{};
 
    struct primop_t { };
    constexpr static primop_t primop{};
 
    struct primOpApp_t { };
    constexpr static primOpApp_t primOpApp{};
 
    struct lambda_t { };
    constexpr static lambda_t lambda{};
 
    struct external_t { };
    constexpr static external_t external{};
 
    struct blackhole_t { };
    constexpr static blackhole_t blackhole{};
};
 
struct Value
{
private:
    InternalType internalType;
 
    friend std::string showType(const Value & v);
 
public:

    static Value EMPTY_LIST;
 
    // Discount `using NewValueAs::*;`
// NOLINTNEXTLINE(bugprone-macro-parentheses)
#define USING_VALUETYPE(name) using name = NewValueAs::name
    USING_VALUETYPE(integer_t);
    USING_VALUETYPE(floating_t);
    USING_VALUETYPE(boolean_t);
    USING_VALUETYPE(string_t);
    USING_VALUETYPE(path_t);
    USING_VALUETYPE(list_t);
    USING_VALUETYPE(attrs_t);
    USING_VALUETYPE(thunk_t);
    USING_VALUETYPE(primop_t);
    USING_VALUETYPE(app_t);
    USING_VALUETYPE(null_t);
    USING_VALUETYPE(primOpApp_t);
    USING_VALUETYPE(lambda_t);
    USING_VALUETYPE(external_t);
    USING_VALUETYPE(blackhole_t);
#undef USING_VALUETYPE

    [[deprecated]] Value()
        : internalType(static_cast<InternalType>(0))
        , _empty{ 0, 0 }
    { }

    Value(integer_t, NixInt i)
        : internalType(tInt)
        , _empty{ 0, 0 }
    {
        // the NixInt ctor here is is special because NixInt has a ctor too, so
        // we're not allowed to have it as an anonymous aggreagte member. we do
        // however still have the option to clear the data members using _empty
        // and leaving the second word of data cleared by setting only integer.
        integer = i;
    }

    Value(floating_t, NixFloat f)
        : internalType(tFloat)
        , fpoint(f)
        , _float_pad(0)
    { }

    Value(boolean_t, bool b)
        : internalType(tBool)
        , boolean(b)
        , _bool_pad(0)
    { }

    Value(string_t, char const * strPtr, char const ** contextPtr = nullptr)
        : internalType(tString)
        , string({ .s = strPtr, .context = contextPtr })
    { }

    Value(string_t, std::string_view copyFrom, NixStringContext const & context = {})
        : internalType(tString)
        , string({ .s = gcCopyStringIfNeeded(copyFrom), .context = nullptr })
    {
        if (context.empty()) {
            // It stays nullptr.
            return;
        }
 
        // Copy the context.
        this->string.context = gcAllocType<char const *>(context.size() + 1);
 
        size_t n = 0;
        for (NixStringContextElem const & contextElem : context) {
            this->string.context[n] = gcCopyStringIfNeeded(contextElem.to_string());
            n += 1;
        }
 
        // Terminator sentinel.
        this->string.context[n] = nullptr;
    }

    Value(string_t, char const * strPtr, NixStringContext const & context)
        : internalType(tString)
        , string({ .s = strPtr, .context = nullptr })
    {
        if (context.empty()) {
            // It stays nullptr
            return;
        }
 
        // Copy the context.
        this->string.context = gcAllocType<char const *>(context.size() + 1);
 
        size_t n = 0;
        for (NixStringContextElem const & contextElem : context) {
            this->string.context[n] = gcCopyStringIfNeeded(contextElem.to_string());
            n += 1;
        }
 
        // Terminator sentinel.
        this->string.context[n] = nullptr;
    }

    Value(path_t, char const * strPtr)
        : internalType(tPath)
        , _path(strPtr)
        , _path_pad(0)
    { }

    Value(path_t, SourcePath const & path)
        : internalType(tPath)
        , _path(gcCopyStringIfNeeded(path.canonical().abs()))
        , _path_pad(0)
    { }

    Value(list_t, std::span<Value *> items)
    {
        if (items.size() == 1) {
            this->internalType = tList1;
            this->smallList[0] = items[0];
            this->smallList[1] = nullptr;
        } else if (items.size() == 2) {
            this->internalType = tList2;
            this->smallList[0] = items[0];
            this->smallList[1] = items[1];
        } else {
            this->internalType = tListN;
            this->bigList.size = items.size();
            this->bigList.elems = items.data();
        }
    }

    template<
        std::ranges::sized_range SizedIterableT,
        InvocableR<Value *, typename SizedIterableT::value_type const &> TransformerT
    >
    Value(list_t, SizedIterableT & items, TransformerT const & transformer)
    {
        if (items.size() == 1) {
            this->internalType = tList1;
            this->smallList[0] = transformer(*items.begin());
            this->smallList[1] = nullptr;
        } else if (items.size() == 2) {
            this->internalType = tList2;
            auto it = items.begin();
            this->smallList[0] = transformer(*it);
            it++;
            this->smallList[1] = transformer(*it);
        } else {
            this->internalType = tListN;
            this->bigList.size = items.size();
            this->bigList.elems = gcAllocType<Value *>(items.size());
            auto it = items.begin();
            for (size_t i = 0; i < items.size(); i++, it++) {
                this->bigList.elems[i] = transformer(*it);
            }
        }
    }

    Value(null_t)
        : internalType(tNull)
        , _empty{0, 0}
    { }

    Value(attrs_t, Bindings * bindings)
        : internalType(tAttrs)
        , attrs(bindings)
        , _attrs_pad(0)
    { }

    Value(thunk_t, Env & env, Expr & expr)
        : internalType(tThunk)
        , thunk({ .env = &env, .expr = &expr })
    { }

    Value(primop_t, PrimOp & primop);

    Value(primOpApp_t, Value & lhs, Value & rhs)
        : internalType(tPrimOpApp)
        , primOpApp({ .left = &lhs, .right = &rhs })
    { }

    Value(app_t, Value & lhs, Value & rhs)
        : internalType(tApp)
        , app({ .left = &lhs, .right = &rhs })
    { }

    Value(external_t, ExternalValueBase & external)
        : internalType(tExternal)
        , external(&external)
        , _external_pad(0)
    { }

    Value(lambda_t, Env & env, ExprLambda & lambda)
        : internalType(tLambda)
        , lambda({ .env = &env, .fun = &lambda })
    { }

    explicit Value(blackhole_t)
        : internalType(tThunk)
        , thunk({ .env = nullptr, .expr = eBlackHoleAddr })
    { }
 
    Value(Value const & rhs) = default;

    Value(Value && rhs)
        : internalType(rhs.internalType)
        , _empty{ 0, 0 }
    {
        *this = std::move(rhs);
    }
 
    Value & operator=(Value const & rhs) = default;

    inline Value & operator=(Value && rhs)
    {
        *this = static_cast<const Value &>(rhs);
        if (this != &rhs) {
            // Kill `rhs`, because non-destructive move lol.
            rhs.internalType = static_cast<InternalType>(0);
            rhs._empty[0] = 0;
            rhs._empty[1] = 0;
        }
        return *this;
    }
 
    void print(EvalState &state, std::ostream &str, PrintOptions options = PrintOptions {});
 
    // Functions needed to distinguish the type
    // These should be removed eventually, by putting the functionality that's
    // needed by callers into methods of this type
 
    // type() == nThunk
    inline bool isThunk() const { return internalType == tThunk; };
    inline bool isApp() const { return internalType == tApp; };
    inline bool isBlackhole() const
    {
        return internalType == tThunk && thunk.expr == eBlackHoleAddr;
    }
 
    // type() == nFunction
    inline bool isLambda() const { return internalType == tLambda; };
    inline bool isPrimOp() const { return internalType == tPrimOp; };
    inline bool isPrimOpApp() const { return internalType == tPrimOpApp; };
 
    union
    {
        uintptr_t _empty[2];
 
        NixInt integer;
        struct {
            bool boolean;
            uintptr_t _bool_pad;
        };

        struct {
            const char * s;
            const char * * context; // must be in sorted order
        } string;
 
        struct {
            const char * _path;
            uintptr_t _path_pad;
        };
        struct {
            Bindings * attrs;
            uintptr_t _attrs_pad;
        };
        struct {
            size_t size;
            Value * * elems;
        } bigList;
        Value * smallList[2];
        struct {
            Env * env;
            Expr * expr;
        } thunk;
        struct {
            Value * left, * right;
        } app;
        struct {
            Env * env;
            ExprLambda * fun;
        } lambda;
        struct {
            PrimOp * primOp;
            uintptr_t _primop_pad;
        };
        struct {
            Value * left, * right;
        } primOpApp;
        struct {
            ExternalValueBase * external;
            uintptr_t _external_pad;
        };
        struct {
            NixFloat fpoint;
            uintptr_t _float_pad;
        };
    };

    inline ValueType type(bool invalidIsThunk = false) const
    {
        switch (internalType) {
            case tInt: return nInt;
            case tBool: return nBool;
            case tString: return nString;
            case tPath: return nPath;
            case tNull: return nNull;
            case tAttrs: return nAttrs;
            case tList1: case tList2: case tListN: return nList;
            case tLambda: case tPrimOp: case tPrimOpApp: return nFunction;
            case tExternal: return nExternal;
            case tFloat: return nFloat;
            case tThunk: case tApp: return nThunk;
        }
        if (invalidIsThunk)
            return nThunk;
        else
            abort();
    }

    inline void clearValue()
    {
        app.left = app.right = 0;
    }
 
    inline void mkInt(NixInt::Inner n)
    {
        mkInt(NixInt{n});
    }
 
    inline void mkInt(NixInt n)
    {
        clearValue();
        internalType = tInt;
        integer = n;
    }
 
    inline void mkBool(bool b)
    {
        clearValue();
        internalType = tBool;
        boolean = b;
    }
 
    inline void mkString(const char * s, const char * * context = 0)
    {
        internalType = tString;
        string.s = s;
        string.context = context;
    }
 
    void mkString(std::string_view s);
 
    void mkString(std::string_view s, const NixStringContext & context);
 
    void mkStringMove(const char * s, const NixStringContext & context);
 
    void mkPath(const SourcePath & path);
 
    inline void mkPath(const char * path)
    {
        clearValue();
        internalType = tPath;
        _path = path;
    }
 
    inline void mkNull()
    {
        clearValue();
        internalType = tNull;
    }
 
    inline void mkAttrs(Bindings * a)
    {
        clearValue();
        internalType = tAttrs;
        attrs = a;
    }
 
    Value & mkAttrs(BindingsBuilder & bindings);
 
    inline void mkList(size_t size)
    {
        clearValue();
        if (size == 1)
            internalType = tList1;
        else if (size == 2)
            internalType = tList2;
        else {
            internalType = tListN;
            bigList.size = size;
        }
    }
 
    inline void mkThunk(Env * e, Expr & ex)
    {
        internalType = tThunk;
        thunk.env = e;
        thunk.expr = &ex;
    }
 
    inline void mkApp(Value * l, Value * r)
    {
        internalType = tApp;
        app.left = l;
        app.right = r;
    }
 
    inline void mkLambda(Env * e, ExprLambda * f)
    {
        internalType = tLambda;
        lambda.env = e;
        lambda.fun = f;
    }
 
    inline void mkBlackhole()
    {
        internalType = tThunk;
        thunk.expr = eBlackHoleAddr;
    }
 
    void mkPrimOp(PrimOp * p);
 
    inline void mkPrimOpApp(Value * l, Value * r)
    {
        internalType = tPrimOpApp;
        primOpApp.left = l;
        primOpApp.right = r;
    }

    PrimOp * primOpAppPrimOp() const;
 
    inline void mkExternal(ExternalValueBase * e)
    {
        clearValue();
        internalType = tExternal;
        external = e;
    }
 
    inline void mkFloat(NixFloat n)
    {
        clearValue();
        internalType = tFloat;
        fpoint = n;
    }
 
    bool isList() const
    {
        return internalType == tList1 || internalType == tList2 || internalType == tListN;
    }
 
    Value * * listElems()
    {
        return internalType == tList1 || internalType == tList2 ? smallList : bigList.elems;
    }
 
    Value * const * listElems() const
    {
        return internalType == tList1 || internalType == tList2 ? smallList : bigList.elems;
    }
 
    size_t listSize() const
    {
        return internalType == tList1 ? 1 : internalType == tList2 ? 2 : bigList.size;
    }

    bool isTrivial() const;
 
    auto listItems()
    {
        struct ListIterable
        {
            typedef Value * const * iterator;
            iterator _begin, _end;
            iterator begin() const { return _begin; }
            iterator end() const { return _end; }
        };
        assert(isList());
        auto begin = listElems();
        return ListIterable { begin, begin + listSize() };
    }
 
    auto listItems() const
    {
        struct ConstListIterable
        {
            typedef const Value * const * iterator;
            iterator _begin, _end;
            iterator begin() const { return _begin; }
            iterator end() const { return _end; }
        };
        assert(isList());
        auto begin = listElems();
        return ConstListIterable { begin, begin + listSize() };
    }
 
    SourcePath path() const
    {
        assert(internalType == tPath);
        return SourcePath{CanonPath(_path)};
    }
 
    std::string_view str() const
    {
        assert(internalType == tString);
        return std::string_view(string.s);
    }
};
 
using ValueVector = GcVector<Value *>;
using ValueMap = GcMap<Symbol, Value *>;
using ValueVectorMap = std::map<Symbol, ValueVector>;

typedef std::shared_ptr<Value *> RootValue;
 
RootValue allocRootValue(Value * v);
 
}