2006-02-08 13:21:16 +00:00
|
|
|
|
#include "get-drvs.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
#include "util.hh"
|
2012-02-04 13:50:25 +00:00
|
|
|
|
#include "eval-inline.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
2013-11-19 13:09:03 +00:00
|
|
|
|
#include <cstring>
|
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
|
|
|
|
namespace nix {
|
2006-02-08 13:21:16 +00:00
|
|
|
|
|
|
|
|
|
|
2013-11-19 13:09:03 +00:00
|
|
|
|
string DrvInfo::queryDrvPath()
|
2006-03-10 16:20:42 +00:00
|
|
|
|
{
|
2010-04-19 12:10:04 +00:00
|
|
|
|
if (drvPath == "" && attrs) {
|
2013-11-19 13:09:03 +00:00
|
|
|
|
Bindings::iterator i = attrs->find(state->sDrvPath);
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
2014-04-04 20:19:33 +00:00
|
|
|
|
drvPath = i != attrs->end() ? state->coerceToPath(*i->pos, *i->value, context) : "";
|
2006-03-10 16:20:42 +00:00
|
|
|
|
}
|
|
|
|
|
return drvPath;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-19 13:09:03 +00:00
|
|
|
|
string DrvInfo::queryOutPath()
|
2006-03-10 16:20:42 +00:00
|
|
|
|
{
|
2010-04-19 12:10:04 +00:00
|
|
|
|
if (outPath == "" && attrs) {
|
2013-11-19 13:09:03 +00:00
|
|
|
|
Bindings::iterator i = attrs->find(state->sOutPath);
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
2014-04-04 20:19:33 +00:00
|
|
|
|
outPath = i != attrs->end() ? state->coerceToPath(*i->pos, *i->value, context) : "";
|
2006-03-10 16:20:42 +00:00
|
|
|
|
}
|
|
|
|
|
return outPath;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-19 13:09:03 +00:00
|
|
|
|
DrvInfo::Outputs DrvInfo::queryOutputs()
|
2012-11-28 12:49:44 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
2012-11-28 12:49:44 +00:00
|
|
|
|
|
|
|
|
|
/* For each output... */
|
|
|
|
|
for (unsigned int j = 0; j < i->value->list.length; ++j) {
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* 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));
|
2012-11-28 12:49:44 +00:00
|
|
|
|
if (out == attrs->end()) continue; // FIXME: throw error?
|
2013-11-19 13:09:03 +00:00
|
|
|
|
state->forceAttrs(*out->value);
|
2012-11-28 12:49:44 +00:00
|
|
|
|
|
|
|
|
|
/* And evaluate its ‘outPath’ attribute. */
|
2013-11-19 13:09:03 +00:00
|
|
|
|
Bindings::iterator outPath = out->value->attrs->find(state->sOutPath);
|
2012-11-28 12:49:44 +00:00
|
|
|
|
if (outPath == out->value->attrs->end()) continue; // FIXME: throw error?
|
|
|
|
|
PathSet context;
|
2014-04-04 20:19:33 +00:00
|
|
|
|
outputs[name] = state->coerceToPath(*outPath->pos, *outPath->value, context);
|
2012-11-28 12:49:44 +00:00
|
|
|
|
}
|
2013-11-19 13:09:03 +00:00
|
|
|
|
} else
|
|
|
|
|
outputs["out"] = queryOutPath();
|
2012-11-28 12:49:44 +00:00
|
|
|
|
}
|
|
|
|
|
return outputs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-19 13:09:03 +00:00
|
|
|
|
string DrvInfo::queryOutputName()
|
2012-11-26 16:39:09 +00:00
|
|
|
|
{
|
|
|
|
|
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) : "";
|
2012-11-26 16:39:09 +00:00
|
|
|
|
}
|
|
|
|
|
return outputName;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-19 13:09:03 +00:00
|
|
|
|
Bindings * DrvInfo::getMeta()
|
2006-03-10 16:20:42 +00:00
|
|
|
|
{
|
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;
|
2006-03-10 16:20:42 +00:00
|
|
|
|
return meta;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-19 13:09:03 +00:00
|
|
|
|
StringSet DrvInfo::queryMetaNames()
|
2007-05-01 20:33:18 +00:00
|
|
|
|
{
|
2013-11-19 13:09:03 +00:00
|
|
|
|
StringSet res;
|
|
|
|
|
if (!getMeta()) return res;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : *meta)
|
|
|
|
|
res.insert(i.name);
|
2013-11-19 13:09:03 +00:00
|
|
|
|
return res;
|
2007-05-01 20:33:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-19 13:29:39 +00:00
|
|
|
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : *v.attrs)
|
|
|
|
|
if (!checkMeta(*i.value)) return false;
|
2013-11-19 13:29:39 +00:00
|
|
|
|
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)
|
2007-02-02 01:52:42 +00:00
|
|
|
|
{
|
2013-11-19 13:09:03 +00:00
|
|
|
|
if (!getMeta()) return 0;
|
|
|
|
|
Bindings::iterator a = meta->find(state->symbols.create(name));
|
2013-11-19 13:29:39 +00:00
|
|
|
|
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;
|
2014-09-19 14:49:41 +00:00
|
|
|
|
meta = state->allocBindings(1 + (old ? old->size() : 0));
|
2013-11-19 13:09:03 +00:00
|
|
|
|
Symbol sym = state->symbols.create(name);
|
|
|
|
|
if (old)
|
2014-09-19 14:49:41 +00:00
|
|
|
|
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
|
|
|
|
}
|
2007-02-02 01:52:42 +00:00
|
|
|
|
|
|
|
|
|
|
2010-04-01 12:04:57 +00:00
|
|
|
|
/* Cache for already considered attrsets. */
|
|
|
|
|
typedef set<Bindings *> Done;
|
2006-02-08 16:15:07 +00:00
|
|
|
|
|
|
|
|
|
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* 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,
|
2012-10-04 19:22:25 +00:00
|
|
|
|
const string & attrPath, DrvInfos & drvs, Done & done,
|
|
|
|
|
bool ignoreAssertionFailures)
|
2006-02-08 13:21:16 +00:00
|
|
|
|
{
|
2006-03-08 16:03:58 +00:00
|
|
|
|
try {
|
2010-03-31 15:38:03 +00:00
|
|
|
|
state.forceValue(v);
|
2010-04-07 13:55:46 +00:00
|
|
|
|
if (!state.isDerivation(v)) return true;
|
2006-02-08 13:21:16 +00:00
|
|
|
|
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* 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);
|
2006-02-08 16:15:07 +00:00
|
|
|
|
|
2010-04-13 12:25:42 +00:00
|
|
|
|
Bindings::iterator i = v.attrs->find(state.sName);
|
2006-05-30 11:31:33 +00:00
|
|
|
|
/* !!! 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");
|
2006-02-08 13:21:16 +00:00
|
|
|
|
|
2010-10-22 14:47:42 +00:00
|
|
|
|
Bindings::iterator i2 = v.attrs->find(state.sSystem);
|
2006-02-08 13:21:16 +00:00
|
|
|
|
|
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);
|
2006-07-25 16:40:38 +00:00
|
|
|
|
|
2006-03-08 16:03:58 +00:00
|
|
|
|
drvs.push_back(drv);
|
|
|
|
|
return false;
|
2012-11-28 12:49:44 +00:00
|
|
|
|
|
2006-03-08 16:03:58 +00:00
|
|
|
|
} catch (AssertionError & e) {
|
2012-10-04 19:22:25 +00:00
|
|
|
|
if (ignoreAssertionFailures) return false;
|
|
|
|
|
throw;
|
2006-03-08 16:03:58 +00:00
|
|
|
|
}
|
2006-02-08 13:21:16 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-10-04 19:22:25 +00:00
|
|
|
|
bool getDerivation(EvalState & state, Value & v, DrvInfo & drv,
|
|
|
|
|
bool ignoreAssertionFailures)
|
2006-02-08 16:15:07 +00:00
|
|
|
|
{
|
2010-04-01 12:04:57 +00:00
|
|
|
|
Done done;
|
2006-02-08 16:15:07 +00:00
|
|
|
|
DrvInfos drvs;
|
2012-10-04 19:22:25 +00:00
|
|
|
|
getDerivation(state, v, "", drvs, done, ignoreAssertionFailures);
|
2006-03-08 16:03:58 +00:00
|
|
|
|
if (drvs.size() != 1) return false;
|
|
|
|
|
drv = drvs.front();
|
|
|
|
|
return true;
|
2006-02-08 16:15:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-07-25 16:40:38 +00:00
|
|
|
|
static string addToPath(const string & s1, const string & s2)
|
|
|
|
|
{
|
|
|
|
|
return s1.empty() ? s2 : s1 + "." + s2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-07 15:47:06 +00:00
|
|
|
|
static void getDerivations(EvalState & state, Value & vIn,
|
2010-10-22 14:47:42 +00:00
|
|
|
|
const string & pathPrefix, Bindings & autoArgs,
|
2012-10-04 19:22:25 +00:00
|
|
|
|
DrvInfos & drvs, Done & done,
|
|
|
|
|
bool ignoreAssertionFailures)
|
2006-02-08 13:21:16 +00:00
|
|
|
|
{
|
2010-04-07 15:47:06 +00:00
|
|
|
|
Value v;
|
|
|
|
|
state.autoCallFunction(autoArgs, vIn, v);
|
2012-11-28 12:49:44 +00:00
|
|
|
|
|
2006-02-10 17:25:59 +00:00
|
|
|
|
/* Process the expression. */
|
2012-10-04 19:22:25 +00:00
|
|
|
|
if (!getDerivation(state, v, pathPrefix, drvs, done, ignoreAssertionFailures)) ;
|
2006-03-08 16:03:58 +00:00
|
|
|
|
|
2010-03-31 15:38:03 +00:00
|
|
|
|
else if (v.type == tAttrs) {
|
2007-05-01 23:16:38 +00:00
|
|
|
|
|
2007-09-17 16:08:24 +00:00
|
|
|
|
/* !!! undocumented hackery to support combining channels in
|
|
|
|
|
nix-env.cc. */
|
2010-04-13 12:25:42 +00:00
|
|
|
|
bool combineChannels = v.attrs->find(state.symbols.create("_combineChannels")) != v.attrs->end();
|
2008-08-25 14:15:56 +00:00
|
|
|
|
|
2008-08-25 14:31:29 +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). */
|
2010-04-16 13:44:02 +00:00
|
|
|
|
typedef std::map<string, Symbol> SortedSymbols;
|
|
|
|
|
SortedSymbols attrs;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : *v.attrs)
|
|
|
|
|
attrs.insert(std::pair<string, Symbol>(i.name, i.name));
|
2010-03-31 15:38:03 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : attrs) {
|
|
|
|
|
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)
|
2012-10-04 19:22:25 +00:00
|
|
|
|
getDerivations(state, v2, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
|
|
|
|
|
else if (getDerivation(state, v2, pathPrefix2, drvs, done, ignoreAssertionFailures)) {
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* 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) {
|
2010-04-13 12:25:42 +00:00
|
|
|
|
Bindings::iterator j = v2.attrs->find(state.symbols.create("recurseForDerivations"));
|
2010-10-24 00:41:29 +00:00
|
|
|
|
if (j != v2.attrs->end() && state.forceBool(*j->value))
|
2012-10-04 19:22:25 +00:00
|
|
|
|
getDerivations(state, v2, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
|
2006-03-23 16:43:07 +00:00
|
|
|
|
}
|
2006-02-10 17:25:59 +00:00
|
|
|
|
}
|
2006-02-08 13:21:16 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-31 15:38:03 +00:00
|
|
|
|
else if (v.type == tList) {
|
|
|
|
|
for (unsigned int n = 0; n < v.list.length; ++n) {
|
2006-03-08 16:03:58 +00:00
|
|
|
|
startNest(nest, lvlDebug,
|
|
|
|
|
format("evaluating list element"));
|
2006-07-26 15:05:15 +00:00
|
|
|
|
string pathPrefix2 = addToPath(pathPrefix, (format("%1%") % n).str());
|
2012-10-04 19:22:25 +00:00
|
|
|
|
if (getDerivation(state, *v.list.elems[n], pathPrefix2, drvs, done, ignoreAssertionFailures))
|
|
|
|
|
getDerivations(state, *v.list.elems[n], pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
|
2006-02-08 15:22:30 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2006-02-08 13:21:16 +00:00
|
|
|
|
|
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)");
|
2006-02-08 15:22:30 +00:00
|
|
|
|
}
|
2006-02-08 16:15:07 +00:00
|
|
|
|
|
|
|
|
|
|
2010-03-31 15:38:03 +00:00
|
|
|
|
void getDerivations(EvalState & state, Value & v, const string & pathPrefix,
|
2012-10-04 19:22:25 +00:00
|
|
|
|
Bindings & autoArgs, DrvInfos & drvs, bool ignoreAssertionFailures)
|
2006-02-08 16:15:07 +00:00
|
|
|
|
{
|
2010-04-01 12:04:57 +00:00
|
|
|
|
Done done;
|
2012-10-04 19:22:25 +00:00
|
|
|
|
getDerivations(state, v, pathPrefix, autoArgs, drvs, done, ignoreAssertionFailures);
|
2006-02-08 16:15:07 +00:00
|
|
|
|
}
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
2012-11-28 12:49:44 +00:00
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
}
|