2012-07-18 18:59:03 +00:00
|
|
|
#pragma once
|
2012-01-07 17:26:33 +00:00
|
|
|
|
|
|
|
#include "symbol-table.hh"
|
|
|
|
|
2016-08-30 11:12:12 +00:00
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
#include <gc/gc_allocator.h>
|
|
|
|
#endif
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
namespace nix {
|
|
|
|
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
tInt = 1,
|
|
|
|
tBool,
|
|
|
|
tString,
|
|
|
|
tPath,
|
|
|
|
tNull,
|
|
|
|
tAttrs,
|
2015-07-23 20:05:09 +00:00
|
|
|
tList1,
|
|
|
|
tList2,
|
|
|
|
tListN,
|
2012-01-07 17:26:33 +00:00
|
|
|
tThunk,
|
|
|
|
tApp,
|
|
|
|
tLambda,
|
|
|
|
tBlackhole,
|
|
|
|
tPrimOp,
|
|
|
|
tPrimOpApp,
|
2014-11-30 18:16:19 +00:00
|
|
|
tExternal,
|
2016-01-04 23:40:40 +00:00
|
|
|
tFloat
|
2012-01-07 17:26:33 +00:00
|
|
|
} ValueType;
|
|
|
|
|
|
|
|
|
2014-01-21 17:29:55 +00:00
|
|
|
class Bindings;
|
2012-01-07 17:26:33 +00:00
|
|
|
struct Env;
|
|
|
|
struct Expr;
|
|
|
|
struct ExprLambda;
|
|
|
|
struct PrimOp;
|
|
|
|
struct PrimOp;
|
2014-01-21 17:29:55 +00:00
|
|
|
class Symbol;
|
2014-11-30 18:16:19 +00:00
|
|
|
struct Pos;
|
|
|
|
class EvalState;
|
|
|
|
class XMLWriter;
|
2016-08-26 16:55:55 +00:00
|
|
|
class JSONPlaceholder;
|
2012-01-07 17:26:33 +00:00
|
|
|
|
|
|
|
|
libexpr: Use int64_t for NixInt
Using a 64bit integer on 32bit systems will come with a bit of a
performance overhead, but given that Nix doesn't use a lot of integers
compared to other types, I think the overhead is negligible also
considering that 32bit systems are in decline.
The biggest advantage however is that when we use a consistent integer
size across all platforms it's less likely that we miss things that we
break due to that. One example would be:
https://github.com/NixOS/nixpkgs/pull/44233
On Hydra it will evaluate, because the evaluator runs on a 64bit
machine, but when evaluating the same on a 32bit machine it will fail,
so using 64bit integers should make that consistent.
While the change of the type in value.hh is rather easy to do, we have a
few more options available for doing the conversion in the lexer:
* Via an #ifdef on the architecture and using strtol() or strtoll()
accordingly depending on which architecture we are. For the #ifdef
we would need another AX_COMPILE_CHECK_SIZEOF in configure.ac.
* Using istringstream, which would involve copying the value.
* As we're already using boost, lexical_cast might be a good idea.
Spoiler: I went for the latter, first of all because lexical_cast does
have an overload for const char* and second of all, because it doesn't
involve copying around the input string. Also, because istringstream
seems to come with a bigger overhead than boost::lexical_cast:
https://www.boost.org/doc/libs/release/doc/html/boost_lexical_cast/performance.html
The first method (still using strtol/strtoll) also wasn't something I
pursued further, because it is also locale-aware which I doubt is what
we want, given that the regex for int is [0-9]+.
Signed-off-by: aszlig <aszlig@nix.build>
Fixes: #2339
2018-08-28 22:23:51 +00:00
|
|
|
typedef int64_t NixInt;
|
2018-07-03 16:04:51 +00:00
|
|
|
typedef double NixFloat;
|
2013-08-19 10:35:03 +00:00
|
|
|
|
2014-11-30 18:16:19 +00:00
|
|
|
/* External values must descend from ExternalValueBase, so that
|
|
|
|
* type-agnostic nix functions (e.g. showType) can be implemented
|
|
|
|
*/
|
|
|
|
class ExternalValueBase
|
|
|
|
{
|
2014-12-02 15:02:03 +00:00
|
|
|
friend std::ostream & operator << (std::ostream & str, const ExternalValueBase & v);
|
2014-11-30 18:16:19 +00:00
|
|
|
protected:
|
|
|
|
/* Print out the value */
|
2014-12-02 15:02:03 +00:00
|
|
|
virtual std::ostream & print(std::ostream & str) const = 0;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
/* Return a simple string describing the type */
|
2014-12-02 15:02:03 +00:00
|
|
|
virtual string showType() const = 0;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
/* Return a string to be used in builtins.typeOf */
|
2014-12-02 15:02:03 +00:00
|
|
|
virtual string typeOf() const = 0;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
/* How much space does this value take up */
|
2014-12-02 15:02:03 +00:00
|
|
|
virtual size_t valueSize(std::set<const void *> & seen) const = 0;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
/* Coerce the value to a string. Defaults to uncoercable, i.e. throws an
|
|
|
|
* error
|
|
|
|
*/
|
2014-12-02 15:02:03 +00:00
|
|
|
virtual string coerceToString(const Pos & pos, PathSet & context, bool copyMore, bool copyToStore) const;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
/* Compare to another value of the same type. Defaults to uncomparable,
|
|
|
|
* i.e. always false.
|
|
|
|
*/
|
2014-12-02 15:02:03 +00:00
|
|
|
virtual bool operator==(const ExternalValueBase & b) const;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
/* Print the value as JSON. Defaults to unconvertable, i.e. throws an error */
|
|
|
|
virtual void printValueAsJSON(EvalState & state, bool strict,
|
2016-08-26 16:55:55 +00:00
|
|
|
JSONPlaceholder & out, PathSet & context) const;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
/* Print the value as XML. Defaults to unevaluated */
|
|
|
|
virtual void printValueAsXML(EvalState & state, bool strict, bool location,
|
2014-12-02 15:02:03 +00:00
|
|
|
XMLWriter & doc, PathSet & context, PathSet & drvsSeen) const;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
|
|
virtual ~ExternalValueBase()
|
|
|
|
{
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-12-02 15:02:03 +00:00
|
|
|
std::ostream & operator << (std::ostream & str, const ExternalValueBase & v);
|
2014-11-30 18:16:19 +00:00
|
|
|
|
2013-08-19 10:35:03 +00:00
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
struct Value
|
|
|
|
{
|
|
|
|
ValueType type;
|
2013-08-19 10:35:03 +00:00
|
|
|
union
|
2012-01-07 17:26:33 +00:00
|
|
|
{
|
2013-08-19 10:35:03 +00:00
|
|
|
NixInt integer;
|
2012-01-07 17:26:33 +00:00
|
|
|
bool boolean;
|
2013-08-19 10:35:03 +00:00
|
|
|
|
2013-08-06 12:15:11 +00:00
|
|
|
/* Strings in the evaluator carry a so-called `context' which
|
|
|
|
is a list of strings representing store paths. This is to
|
|
|
|
allow users to write things like
|
2012-01-07 17:26:33 +00:00
|
|
|
|
|
|
|
"--with-freetype2-library=" + freetype + "/lib"
|
|
|
|
|
|
|
|
where `freetype' is a derivation (or a source to be copied
|
|
|
|
to the store). If we just concatenated the strings without
|
|
|
|
keeping track of the referenced store paths, then if the
|
|
|
|
string is used as a derivation attribute, the derivation
|
|
|
|
will not have the correct dependencies in its inputDrvs and
|
|
|
|
inputSrcs.
|
|
|
|
|
|
|
|
The semantics of the context is as follows: when a string
|
|
|
|
with context C is used as a derivation attribute, then the
|
|
|
|
derivations in C will be added to the inputDrvs of the
|
|
|
|
derivation, and the other store paths in C will be added to
|
|
|
|
the inputSrcs of the derivations.
|
|
|
|
|
|
|
|
For canonicity, the store paths should be in sorted order. */
|
|
|
|
struct {
|
|
|
|
const char * s;
|
|
|
|
const char * * context; // must be in sorted order
|
|
|
|
} string;
|
2013-08-19 10:35:03 +00:00
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
const char * path;
|
|
|
|
Bindings * attrs;
|
|
|
|
struct {
|
2018-05-02 11:56:34 +00:00
|
|
|
size_t size;
|
2012-01-07 17:26:33 +00:00
|
|
|
Value * * elems;
|
2015-07-23 20:05:09 +00:00
|
|
|
} bigList;
|
|
|
|
Value * smallList[2];
|
2012-01-07 17:26:33 +00:00
|
|
|
struct {
|
|
|
|
Env * env;
|
|
|
|
Expr * expr;
|
|
|
|
} thunk;
|
|
|
|
struct {
|
|
|
|
Value * left, * right;
|
|
|
|
} app;
|
|
|
|
struct {
|
|
|
|
Env * env;
|
|
|
|
ExprLambda * fun;
|
|
|
|
} lambda;
|
|
|
|
PrimOp * primOp;
|
|
|
|
struct {
|
|
|
|
Value * left, * right;
|
|
|
|
} primOpApp;
|
2014-11-30 18:16:19 +00:00
|
|
|
ExternalValueBase * external;
|
2016-01-04 23:40:40 +00:00
|
|
|
NixFloat fpoint;
|
2012-01-07 17:26:33 +00:00
|
|
|
};
|
2015-07-23 20:05:09 +00:00
|
|
|
|
|
|
|
bool isList() const
|
|
|
|
{
|
|
|
|
return type == tList1 || type == tList2 || type == tListN;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value * * listElems()
|
|
|
|
{
|
|
|
|
return type == tList1 || type == tList2 ? smallList : bigList.elems;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Value * const * listElems() const
|
|
|
|
{
|
|
|
|
return type == tList1 || type == tList2 ? smallList : bigList.elems;
|
|
|
|
}
|
|
|
|
|
2018-05-02 11:56:34 +00:00
|
|
|
size_t listSize() const
|
2015-07-23 20:05:09 +00:00
|
|
|
{
|
|
|
|
return type == tList1 ? 1 : type == tList2 ? 2 : bigList.size;
|
|
|
|
}
|
2019-09-09 15:34:38 +00:00
|
|
|
|
|
|
|
/* Check whether forcing this value requires a trivial amount of
|
|
|
|
computation. In particular, function applications are
|
|
|
|
non-trivial. */
|
|
|
|
bool isTrivial() const;
|
2012-01-07 17:26:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* After overwriting an app node, be sure to clear pointers in the
|
|
|
|
Value to ensure that the target isn't kept alive unnecessarily. */
|
|
|
|
static inline void clearValue(Value & v)
|
|
|
|
{
|
2014-10-09 11:08:53 +00:00
|
|
|
v.app.left = v.app.right = 0;
|
2012-01-07 17:26:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-19 10:35:03 +00:00
|
|
|
static inline void mkInt(Value & v, NixInt n)
|
2012-01-07 17:26:33 +00:00
|
|
|
{
|
|
|
|
clearValue(v);
|
|
|
|
v.type = tInt;
|
|
|
|
v.integer = n;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-04 23:40:40 +00:00
|
|
|
static inline void mkFloat(Value & v, NixFloat n)
|
|
|
|
{
|
|
|
|
clearValue(v);
|
|
|
|
v.type = tFloat;
|
|
|
|
v.fpoint = n;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
static inline void mkBool(Value & v, bool b)
|
|
|
|
{
|
|
|
|
clearValue(v);
|
|
|
|
v.type = tBool;
|
|
|
|
v.boolean = b;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-11-18 21:22:35 +00:00
|
|
|
static inline void mkNull(Value & v)
|
|
|
|
{
|
2014-10-09 11:08:53 +00:00
|
|
|
clearValue(v);
|
2013-11-18 21:22:35 +00:00
|
|
|
v.type = tNull;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
static inline void mkApp(Value & v, Value & left, Value & right)
|
|
|
|
{
|
|
|
|
v.type = tApp;
|
|
|
|
v.app.left = &left;
|
|
|
|
v.app.right = &right;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-04-25 09:20:37 +00:00
|
|
|
static inline void mkPrimOpApp(Value & v, Value & left, Value & right)
|
|
|
|
{
|
|
|
|
v.type = tPrimOpApp;
|
|
|
|
v.app.left = &left;
|
|
|
|
v.app.right = &right;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
static inline void mkStringNoCopy(Value & v, const char * s)
|
|
|
|
{
|
|
|
|
v.type = tString;
|
|
|
|
v.string.s = s;
|
|
|
|
v.string.context = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline void mkString(Value & v, const Symbol & s)
|
|
|
|
{
|
2012-12-13 05:13:26 +00:00
|
|
|
mkStringNoCopy(v, ((const string &) s).c_str());
|
2012-01-07 17:26:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void mkString(Value & v, const char * s);
|
|
|
|
|
|
|
|
|
|
|
|
static inline void mkPathNoCopy(Value & v, const char * s)
|
|
|
|
{
|
|
|
|
clearValue(v);
|
|
|
|
v.type = tPath;
|
|
|
|
v.path = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void mkPath(Value & v, const char * s);
|
|
|
|
|
|
|
|
|
2014-09-22 12:46:42 +00:00
|
|
|
/* Compute the size in bytes of the given value, including all values
|
|
|
|
and environments reachable from it. Static expressions (Exprs) are
|
|
|
|
not included. */
|
|
|
|
size_t valueSize(Value & v);
|
|
|
|
|
|
|
|
|
2016-08-29 15:28:20 +00:00
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
typedef std::vector<Value *, gc_allocator<Value *> > ValueVector;
|
2017-03-24 22:05:49 +00:00
|
|
|
typedef std::map<Symbol, Value *, std::less<Symbol>, gc_allocator<std::pair<const Symbol, Value *> > > ValueMap;
|
2016-08-29 15:28:20 +00:00
|
|
|
#else
|
|
|
|
typedef std::vector<Value *> ValueVector;
|
|
|
|
typedef std::map<Symbol, Value *> ValueMap;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
}
|