lix/src/libexpr/get-drvs.cc

303 lines
9.4 KiB
C++
Raw Normal View History

#include "get-drvs.hh"
#include "util.hh"
#include "eval-inline.hh"
2013-11-19 13:09:03 +00:00
#include <cstring>
namespace nix {
2013-11-19 13:09:03 +00:00
string DrvInfo::queryDrvPath()
{
if (drvPath == "" && attrs) {
2013-11-19 13:09:03 +00:00
Bindings::iterator i = attrs->find(state->sDrvPath);
PathSet context;
drvPath = i != attrs->end() ? state->coerceToPath(*i->pos, *i->value, context) : "";
}
return drvPath;
}
2013-11-19 13:09:03 +00:00
string DrvInfo::queryOutPath()
{
if (outPath == "" && attrs) {
2013-11-19 13:09:03 +00:00
Bindings::iterator i = attrs->find(state->sOutPath);
PathSet context;
outPath = i != attrs->end() ? state->coerceToPath(*i->pos, *i->value, context) : "";
}
return outPath;
}
2013-11-19 13:09:03 +00:00
DrvInfo::Outputs DrvInfo::queryOutputs()
{
if (outputs.empty()) {
/* Get the outputs list. */
2013-11-19 13:09:03 +00:00
Bindings::iterator i;
if (attrs && (i = attrs->find(state->sOutputs)) != attrs->end()) {
2014-04-04 17:05:36 +00:00
state->forceList(*i->value, *i->pos);
/* For each output... */
for (unsigned int j = 0; j < i->value->list.length; ++j) {
/* Evaluate the corresponding set. */
2014-04-04 19:14:11 +00:00
string name = state->forceStringNoCtx(*i->value->list.elems[j], *i->pos);
2013-11-19 13:09:03 +00:00
Bindings::iterator out = attrs->find(state->symbols.create(name));
if (out == attrs->end()) continue; // FIXME: throw error?
2013-11-19 13:09:03 +00:00
state->forceAttrs(*out->value);
/* And evaluate its outPath attribute. */
2013-11-19 13:09:03 +00:00
Bindings::iterator outPath = out->value->attrs->find(state->sOutPath);
if (outPath == out->value->attrs->end()) continue; // FIXME: throw error?
PathSet context;
outputs[name] = state->coerceToPath(*outPath->pos, *outPath->value, context);
}
2013-11-19 13:09:03 +00:00
} else
outputs["out"] = queryOutPath();
}
return outputs;
}
2013-11-19 13:09:03 +00:00
string DrvInfo::queryOutputName()
{
if (outputName == "" && attrs) {
2013-11-19 13:09:03 +00:00
Bindings::iterator i = attrs->find(state->sOutputName);
outputName = i != attrs->end() ? state->forceStringNoCtx(*i->value) : "";
}
return outputName;
}
2013-11-19 13:09:03 +00:00
Bindings * DrvInfo::getMeta()
{
2013-11-19 13:09:03 +00:00
if (meta) return meta;
if (!attrs) return 0;
Bindings::iterator a = attrs->find(state->sMeta);
if (a == attrs->end()) return 0;
2014-04-04 17:11:40 +00:00
state->forceAttrs(*a->value, *a->pos);
2013-11-19 13:09:03 +00:00
meta = a->value->attrs;
return meta;
}
2013-11-19 13:09:03 +00:00
StringSet DrvInfo::queryMetaNames()
{
2013-11-19 13:09:03 +00:00
StringSet res;
if (!getMeta()) return res;
foreach (Bindings::iterator, i, *meta)
res.insert(i->name);
return res;
}
bool DrvInfo::checkMeta(Value & v)
{
state->forceValue(v);
if (v.type == tList) {
for (unsigned int n = 0; n < v.list.length; ++n)
if (!checkMeta(*v.list.elems[n])) return false;
return true;
}
else if (v.type == tAttrs) {
Bindings::iterator i = v.attrs->find(state->sOutPath);
if (i != v.attrs->end()) return false;
foreach (Bindings::iterator, i, *v.attrs)
if (!checkMeta(*i->value)) return false;
return true;
}
else return v.type == tInt || v.type == tBool || v.type == tString;
}
2013-11-19 13:09:03 +00:00
Value * DrvInfo::queryMeta(const string & name)
{
2013-11-19 13:09:03 +00:00
if (!getMeta()) return 0;
Bindings::iterator a = meta->find(state->symbols.create(name));
if (a == meta->end() || !checkMeta(*a->value)) return 0;
2013-11-19 13:09:03 +00:00
return a->value;
}
string DrvInfo::queryMetaString(const string & name)
{
Value * v = queryMeta(name);
if (!v || v->type != tString) return "";
return v->string.s;
}
int DrvInfo::queryMetaInt(const string & name, int def)
{
Value * v = queryMeta(name);
if (!v) return def;
if (v->type == tInt) return v->integer;
if (v->type == tString) {
/* Backwards compatibility with before we had support for
integer meta fields. */
int n;
if (string2Int(v->string.s, n)) return n;
}
return def;
}
bool DrvInfo::queryMetaBool(const string & name, bool def)
{
Value * v = queryMeta(name);
if (!v) return def;
if (v->type == tBool) return v->boolean;
if (v->type == tString) {
/* Backwards compatibility with before we had support for
Boolean meta fields. */
if (strcmp(v->string.s, "true") == 0) return true;
if (strcmp(v->string.s, "false") == 0) return false;
}
return def;
}
void DrvInfo::setMeta(const string & name, Value * v)
{
getMeta();
Bindings * old = meta;
meta = state->allocBindings(1 + (old ? old->size() : 0));
2013-11-19 13:09:03 +00:00
Symbol sym = state->symbols.create(name);
if (old)
for (auto i : *old)
if (i.name != sym)
meta->push_back(i);
2013-11-19 13:09:03 +00:00
if (v) meta->push_back(Attr(sym, v));
meta->sort();
2010-03-31 19:12:08 +00:00
}
2010-04-01 12:04:57 +00:00
/* Cache for already considered attrsets. */
typedef set<Bindings *> Done;
/* Evaluate value `v'. If it evaluates to a set of type `derivation',
then put information about it in `drvs' (unless it's already in
`doneExprs'). The result boolean indicates whether it makes sense
for the caller to recursively search for derivations in `v'. */
2010-03-31 15:38:03 +00:00
static bool getDerivation(EvalState & state, Value & v,
const string & attrPath, DrvInfos & drvs, Done & done,
bool ignoreAssertionFailures)
{
try {
2010-03-31 15:38:03 +00:00
state.forceValue(v);
if (!state.isDerivation(v)) return true;
/* Remove spurious duplicates (e.g., a set like `rec { x =
derivation {...}; y = x;}'. */
2010-04-01 12:04:57 +00:00
if (done.find(v.attrs) != done.end()) return false;
done.insert(v.attrs);
Bindings::iterator i = v.attrs->find(state.sName);
/* !!! We really would like to have a decent back trace here. */
2010-03-31 15:38:03 +00:00
if (i == v.attrs->end()) throw TypeError("derivation name missing");
Bindings::iterator i2 = v.attrs->find(state.sSystem);
2014-04-04 19:14:11 +00:00
DrvInfo drv(state, state.forceStringNoCtx(*i->value), attrPath,
i2 == v.attrs->end() ? "unknown" : state.forceStringNoCtx(*i2->value, *i2->pos),
2013-11-19 13:09:03 +00:00
v.attrs);
drvs.push_back(drv);
return false;
} catch (AssertionError & e) {
if (ignoreAssertionFailures) return false;
throw;
}
}
bool getDerivation(EvalState & state, Value & v, DrvInfo & drv,
bool ignoreAssertionFailures)
{
2010-04-01 12:04:57 +00:00
Done done;
DrvInfos drvs;
getDerivation(state, v, "", drvs, done, ignoreAssertionFailures);
if (drvs.size() != 1) return false;
drv = drvs.front();
return true;
}
static string addToPath(const string & s1, const string & s2)
{
return s1.empty() ? s2 : s1 + "." + s2;
}
static void getDerivations(EvalState & state, Value & vIn,
const string & pathPrefix, Bindings & autoArgs,
DrvInfos & drvs, Done & done,
bool ignoreAssertionFailures)
{
Value v;
state.autoCallFunction(autoArgs, vIn, v);
/* Process the expression. */
if (!getDerivation(state, v, pathPrefix, drvs, done, ignoreAssertionFailures)) ;
2010-03-31 15:38:03 +00:00
else if (v.type == tAttrs) {
/* !!! undocumented hackery to support combining channels in
nix-env.cc. */
bool combineChannels = v.attrs->find(state.symbols.create("_combineChannels")) != v.attrs->end();
2008-08-25 14:15:56 +00:00
/* Consider the attributes in sorted order to get more
deterministic behaviour in nix-env operations (e.g. when
there are names clashes between derivations, the derivation
bound to the attribute with the "lower" name should take
precedence). */
typedef std::map<string, Symbol> SortedSymbols;
SortedSymbols attrs;
2010-03-31 15:38:03 +00:00
foreach (Bindings::iterator, i, *v.attrs)
attrs.insert(std::pair<string, Symbol>(i->name, i->name));
2010-03-31 15:38:03 +00:00
foreach (SortedSymbols::iterator, i, attrs) {
2014-08-20 15:00:17 +00:00
startNest(nest, lvlDebug, format("evaluating attribute %1%") % i->first);
string pathPrefix2 = addToPath(pathPrefix, i->first);
Value & v2(*v.attrs->find(i->second)->value);
2008-08-25 14:15:56 +00:00
if (combineChannels)
getDerivations(state, v2, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
else if (getDerivation(state, v2, pathPrefix2, drvs, done, ignoreAssertionFailures)) {
/* If the value of this attribute is itself a set,
should we recurse into it? => Only if it has a
`recurseForDerivations = true' attribute. */
2010-03-31 15:38:03 +00:00
if (v2.type == tAttrs) {
Bindings::iterator j = v2.attrs->find(state.symbols.create("recurseForDerivations"));
if (j != v2.attrs->end() && state.forceBool(*j->value))
getDerivations(state, v2, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
}
}
}
}
2010-03-31 15:38:03 +00:00
else if (v.type == tList) {
for (unsigned int n = 0; n < v.list.length; ++n) {
startNest(nest, lvlDebug,
format("evaluating list element"));
string pathPrefix2 = addToPath(pathPrefix, (format("%1%") % n).str());
if (getDerivation(state, *v.list.elems[n], pathPrefix2, drvs, done, ignoreAssertionFailures))
getDerivations(state, *v.list.elems[n], pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
}
}
2010-03-31 15:38:03 +00:00
else throw TypeError("expression does not evaluate to a derivation (or a set or list of those)");
}
2010-03-31 15:38:03 +00:00
void getDerivations(EvalState & state, Value & v, const string & pathPrefix,
Bindings & autoArgs, DrvInfos & drvs, bool ignoreAssertionFailures)
{
2010-04-01 12:04:57 +00:00
Done done;
getDerivations(state, v, pathPrefix, autoArgs, drvs, done, ignoreAssertionFailures);
}
}