forked from lix-project/lix
d7efd76394
concatenation and string coercion. This was a big mess (see
e.g. NIX-67). Contexts are now folded into strings, so that they
don't cause evaluation errors when they're not expected. The
semantics of paths has been clarified (see nixexpr-ast.def).
toString() and coerceToString() have been merged.
Semantic change: paths are now copied to the store when they're in a
concatenation (and in most other situations - that's the
formalisation of the meaning of a path). So
"foo " + ./bla
evaluates to "foo /nix/store/hash...-bla", not "foo
/path/to/current-dir/bla". This prevents accidental impurities, and
is more consistent with the treatment of derivation outputs, e.g.,
`"foo " + bla' where `bla' is a derivation. (Here `bla' would be
replaced by the output path of `bla'.)
97 lines
2.7 KiB
C++
97 lines
2.7 KiB
C++
#ifndef __EVAL_H
|
|
#define __EVAL_H
|
|
|
|
#include <map>
|
|
|
|
#include "aterm.hh"
|
|
#include "nixexpr.hh"
|
|
|
|
|
|
namespace nix {
|
|
|
|
|
|
class Hash;
|
|
|
|
|
|
typedef std::map<Path, PathSet> DrvRoots;
|
|
typedef std::map<Path, Hash> DrvHashes;
|
|
|
|
/* Cache for calls to addToStore(); maps source paths to the store
|
|
paths. */
|
|
typedef std::map<Path, Path> SrcToStore;
|
|
|
|
struct EvalState;
|
|
|
|
/* Note: using a ATermVector is safe here, since when we call a primop
|
|
we also have an ATermList on the stack. */
|
|
typedef Expr (* PrimOp) (EvalState &, const ATermVector & args);
|
|
|
|
|
|
struct EvalState
|
|
{
|
|
ATermMap normalForms;
|
|
ATermMap primOps;
|
|
DrvRoots drvRoots;
|
|
DrvHashes drvHashes; /* normalised derivation hashes */
|
|
SrcToStore srcToStore;
|
|
|
|
unsigned int nrEvaluated;
|
|
unsigned int nrCached;
|
|
|
|
EvalState();
|
|
|
|
void addPrimOps();
|
|
void addPrimOp(const string & name,
|
|
unsigned int arity, PrimOp primOp);
|
|
};
|
|
|
|
|
|
/* Evaluate an expression to normal form. */
|
|
Expr evalExpr(EvalState & state, Expr e);
|
|
|
|
/* Evaluate an expression read from the given file to normal form. */
|
|
Expr evalFile(EvalState & state, const Path & path);
|
|
|
|
/* Evaluate an expression, and recursively evaluate list elements and
|
|
attributes. If `canonicalise' is true, we remove things like
|
|
position information and make sure that attribute sets are in
|
|
sorded order. */
|
|
Expr strictEvalExpr(EvalState & state, Expr e,
|
|
bool canonicalise = false);
|
|
|
|
/* Specific results. */
|
|
string evalString(EvalState & state, Expr e, PathSet & context);
|
|
string evalStringNoCtx(EvalState & state, Expr e);
|
|
int evalInt(EvalState & state, Expr e);
|
|
bool evalBool(EvalState & state, Expr e);
|
|
ATermList evalList(EvalState & state, Expr e);
|
|
|
|
/* Flatten nested lists into a single list (or expand a singleton into
|
|
a list). */
|
|
ATermList flattenList(EvalState & state, Expr e);
|
|
|
|
/* String coercion. Converts strings, paths and derivations to a
|
|
string. If `coerceMore' is set, also converts nulls, integers,
|
|
booleans and lists to a string. */
|
|
string coerceToString(EvalState & state, Expr e, PathSet & context,
|
|
bool coerceMore = false, bool copyToStore = true);
|
|
|
|
/* Path coercion. Converts strings, paths and derivations to a path.
|
|
The result is guaranteed to be an canonicalised, absolute path.
|
|
Nothing is copied to the store. */
|
|
Path coerceToPath(EvalState & state, Expr e, PathSet & context);
|
|
|
|
/* Automatically call a function for which each argument has a default
|
|
value or has a binding in the `args' map. Note: result is a call,
|
|
not a normal form; it should be evaluated by calling evalExpr(). */
|
|
Expr autoCallFunction(Expr e, const ATermMap & args);
|
|
|
|
/* Print statistics. */
|
|
void printEvalStats(EvalState & state);
|
|
|
|
|
|
}
|
|
|
|
|
|
#endif /* !__EVAL_H */
|