2003-10-29 10:05:18 -05:00
|
|
|
#include "globals.hh"
|
|
|
|
#include "shared.hh"
|
2003-10-30 11:48:26 -05:00
|
|
|
#include "eval.hh"
|
2012-02-04 08:50:25 -05:00
|
|
|
#include "eval-inline.hh"
|
2006-02-10 10:14:57 -05:00
|
|
|
#include "get-drvs.hh"
|
2006-07-26 11:05:15 -04:00
|
|
|
#include "attr-path.hh"
|
2010-04-07 09:59:45 -04:00
|
|
|
#include "value-to-xml.hh"
|
2006-09-04 17:06:23 -04:00
|
|
|
#include "util.hh"
|
2006-11-30 12:43:04 -05:00
|
|
|
#include "store-api.hh"
|
2007-01-14 07:32:44 -05:00
|
|
|
#include "common-opts.hh"
|
2012-11-26 09:39:10 -05:00
|
|
|
#include "misc.hh"
|
2003-12-01 10:55:05 -05:00
|
|
|
|
2010-10-04 13:55:38 -04:00
|
|
|
#include <map>
|
|
|
|
#include <iostream>
|
|
|
|
|
2003-12-01 10:55:05 -05:00
|
|
|
|
2006-09-04 17:06:23 -04:00
|
|
|
using namespace nix;
|
|
|
|
|
|
|
|
|
2003-12-01 10:55:05 -05:00
|
|
|
void printHelp()
|
|
|
|
{
|
2012-10-03 16:37:06 -04:00
|
|
|
showManPage("nix-instantiate");
|
2003-12-01 10:55:05 -05:00
|
|
|
}
|
2003-10-29 10:05:18 -05:00
|
|
|
|
|
|
|
|
2010-04-12 14:30:11 -04:00
|
|
|
static Expr * parseStdin(EvalState & state)
|
2003-10-29 10:05:18 -05:00
|
|
|
{
|
2006-07-26 11:05:15 -04:00
|
|
|
startNest(nest, lvlTalkative, format("parsing standard input"));
|
2012-08-28 11:47:26 -04:00
|
|
|
return state.parseExprFromString(drainFD(0), absPath("."));
|
2003-10-29 10:05:18 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-01 07:36:25 -05:00
|
|
|
static Path gcRoot;
|
|
|
|
static int rootNr = 0;
|
2005-02-01 08:48:46 -05:00
|
|
|
static bool indirectRoot = false;
|
2005-02-01 07:36:25 -05:00
|
|
|
|
|
|
|
|
2007-01-13 13:25:30 -05:00
|
|
|
void processExpr(EvalState & state, const Strings & attrPaths,
|
2010-10-22 10:47:42 -04:00
|
|
|
bool parseOnly, bool strict, Bindings & autoArgs,
|
2010-05-07 10:46:47 -04:00
|
|
|
bool evalOnly, bool xmlOutput, bool location, Expr * e)
|
2006-08-17 04:53:08 -04:00
|
|
|
{
|
2013-09-03 07:04:21 -04:00
|
|
|
if (parseOnly) {
|
2010-04-12 18:03:27 -04:00
|
|
|
std::cout << format("%1%\n") % *e;
|
2013-09-03 07:04:21 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-09-03 09:17:51 -04:00
|
|
|
Value vRoot;
|
|
|
|
state.eval(e, vRoot);
|
|
|
|
|
2013-09-03 07:04:21 -04:00
|
|
|
foreach (Strings::const_iterator, i, attrPaths) {
|
2013-09-03 09:17:51 -04:00
|
|
|
Value & v(*findAlongAttrPath(state, *i, autoArgs, vRoot));
|
2013-09-03 07:04:21 -04:00
|
|
|
state.forceValue(v);
|
|
|
|
|
|
|
|
PathSet context;
|
|
|
|
if (evalOnly)
|
|
|
|
if (xmlOutput)
|
|
|
|
printValueAsXML(state, strict, location, v, std::cout, context);
|
2010-04-07 09:59:45 -04:00
|
|
|
else {
|
2013-09-03 07:04:21 -04:00
|
|
|
if (strict) state.strictForceValue(v);
|
|
|
|
std::cout << v << std::endl;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
DrvInfos drvs;
|
|
|
|
getDerivations(state, v, "", autoArgs, drvs, false);
|
|
|
|
foreach (DrvInfos::iterator, i, drvs) {
|
2013-11-19 08:09:03 -05:00
|
|
|
Path drvPath = i->queryDrvPath();
|
2013-09-03 07:04:21 -04:00
|
|
|
|
|
|
|
/* What output do we want? */
|
2013-11-19 08:09:03 -05:00
|
|
|
string outputName = i->queryOutputName();
|
2013-09-03 07:04:21 -04:00
|
|
|
if (outputName == "")
|
|
|
|
throw Error(format("derivation `%1%' lacks an `outputName' attribute ") % drvPath);
|
|
|
|
|
|
|
|
if (gcRoot == "")
|
|
|
|
printGCWarning();
|
|
|
|
else {
|
|
|
|
Path rootName = gcRoot;
|
|
|
|
if (++rootNr > 1) rootName += "-" + int2String(rootNr);
|
|
|
|
drvPath = addPermRoot(*store, drvPath, rootName, indirectRoot);
|
2010-04-07 11:47:06 -04:00
|
|
|
}
|
2013-09-03 07:04:21 -04:00
|
|
|
std::cout << format("%1%%2%\n") % drvPath % (outputName != "out" ? "!" + outputName : "");
|
2010-03-31 11:38:03 -04:00
|
|
|
}
|
|
|
|
}
|
2013-09-03 07:04:21 -04:00
|
|
|
}
|
2006-08-17 04:53:08 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-29 10:05:18 -05:00
|
|
|
void run(Strings args)
|
|
|
|
{
|
|
|
|
EvalState state;
|
|
|
|
Strings files;
|
|
|
|
bool readStdin = false;
|
2014-02-19 10:30:19 -05:00
|
|
|
bool fromArgs = false;
|
2012-04-17 11:14:14 -04:00
|
|
|
bool findFile = false;
|
2004-10-26 12:59:36 -04:00
|
|
|
bool evalOnly = false;
|
|
|
|
bool parseOnly = false;
|
2006-08-16 06:32:30 -04:00
|
|
|
bool xmlOutput = false;
|
2010-03-31 08:38:31 -04:00
|
|
|
bool xmlOutputSourceLocation = true;
|
2006-08-16 17:59:53 -04:00
|
|
|
bool strict = false;
|
2007-01-13 13:25:30 -05:00
|
|
|
Strings attrPaths;
|
2010-04-07 11:47:06 -04:00
|
|
|
Bindings autoArgs;
|
2014-02-04 10:37:10 -05:00
|
|
|
bool wantsReadWrite = false;
|
2003-10-29 10:05:18 -05:00
|
|
|
|
2010-04-07 11:47:06 -04:00
|
|
|
for (Strings::iterator i = args.begin(); i != args.end(); ) {
|
2005-02-01 07:36:25 -05:00
|
|
|
string arg = *i++;
|
2003-10-29 10:05:18 -05:00
|
|
|
|
2003-12-01 10:55:05 -05:00
|
|
|
if (arg == "-")
|
2003-10-29 10:05:18 -05:00
|
|
|
readStdin = true;
|
2014-02-19 10:30:19 -05:00
|
|
|
else if (arg == "--expr" || arg == "-E")
|
|
|
|
fromArgs = true;
|
2014-02-19 10:34:24 -05:00
|
|
|
else if (arg == "--eval" || arg == "--eval-only")
|
2004-10-26 12:59:36 -04:00
|
|
|
evalOnly = true;
|
2014-02-04 10:37:10 -05:00
|
|
|
else if (arg == "--read-write-mode")
|
|
|
|
wantsReadWrite = true;
|
2014-02-19 10:34:24 -05:00
|
|
|
else if (arg == "--parse" || arg == "--parse-only")
|
2004-10-26 12:59:36 -04:00
|
|
|
parseOnly = evalOnly = true;
|
2012-04-17 11:14:14 -04:00
|
|
|
else if (arg == "--find-file")
|
|
|
|
findFile = true;
|
2006-02-10 12:37:35 -05:00
|
|
|
else if (arg == "--attr" || arg == "-A") {
|
2006-02-10 12:25:59 -05:00
|
|
|
if (i == args.end())
|
2006-07-28 12:03:28 -04:00
|
|
|
throw UsageError("`--attr' requires an argument");
|
2007-01-13 13:25:30 -05:00
|
|
|
attrPaths.push_back(*i++);
|
2006-02-10 12:25:59 -05:00
|
|
|
}
|
2007-01-14 07:32:44 -05:00
|
|
|
else if (parseOptionArg(arg, i, args.end(), state, autoArgs))
|
|
|
|
;
|
2011-08-06 12:05:24 -04:00
|
|
|
else if (parseSearchPathArg(arg, i, args.end(), state))
|
|
|
|
;
|
2006-07-28 12:03:28 -04:00
|
|
|
else if (arg == "--add-root") {
|
|
|
|
if (i == args.end())
|
|
|
|
throw UsageError("`--add-root' requires an argument");
|
|
|
|
gcRoot = absPath(*i++);
|
|
|
|
}
|
2005-02-01 08:48:46 -05:00
|
|
|
else if (arg == "--indirect")
|
|
|
|
indirectRoot = true;
|
2006-08-16 06:32:30 -04:00
|
|
|
else if (arg == "--xml")
|
|
|
|
xmlOutput = true;
|
2010-03-31 08:38:31 -04:00
|
|
|
else if (arg == "--no-location")
|
|
|
|
xmlOutputSourceLocation = false;
|
2006-08-16 17:59:53 -04:00
|
|
|
else if (arg == "--strict")
|
|
|
|
strict = true;
|
2012-10-03 15:09:18 -04:00
|
|
|
else if (arg == "--repair")
|
|
|
|
state.repair = true;
|
2003-10-29 10:05:18 -05:00
|
|
|
else if (arg[0] == '-')
|
2006-07-28 12:03:28 -04:00
|
|
|
throw UsageError(format("unknown flag `%1%'") % arg);
|
2003-10-29 10:05:18 -05:00
|
|
|
else
|
|
|
|
files.push_back(arg);
|
|
|
|
}
|
|
|
|
|
2014-02-04 10:37:10 -05:00
|
|
|
if (evalOnly && !wantsReadWrite)
|
|
|
|
settings.readOnlyMode = true;
|
|
|
|
|
2007-01-13 13:25:30 -05:00
|
|
|
if (attrPaths.empty()) attrPaths.push_back("");
|
|
|
|
|
2012-04-17 11:14:14 -04:00
|
|
|
if (findFile) {
|
|
|
|
foreach (Strings::iterator, i, files) {
|
|
|
|
Path p = state.findFile(*i);
|
|
|
|
if (p == "") throw Error(format("unable to find `%1%'") % *i);
|
|
|
|
std::cout << p << std::endl;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-11-30 12:43:04 -05:00
|
|
|
store = openStore();
|
2003-10-29 10:05:18 -05:00
|
|
|
|
|
|
|
if (readStdin) {
|
2010-04-12 14:30:11 -04:00
|
|
|
Expr * e = parseStdin(state);
|
2007-01-13 13:25:30 -05:00
|
|
|
processExpr(state, attrPaths, parseOnly, strict, autoArgs,
|
2010-03-31 08:38:31 -04:00
|
|
|
evalOnly, xmlOutput, xmlOutputSourceLocation, e);
|
2014-02-19 10:30:19 -05:00
|
|
|
} else if (files.empty() && !fromArgs)
|
2012-04-17 11:19:43 -04:00
|
|
|
files.push_back("./default.nix");
|
2003-10-29 10:05:18 -05:00
|
|
|
|
2010-04-07 11:47:06 -04:00
|
|
|
foreach (Strings::iterator, i, files) {
|
2014-02-19 10:30:19 -05:00
|
|
|
Expr * e = fromArgs
|
|
|
|
? state.parseExprFromString(*i, absPath("."))
|
|
|
|
: state.parseExprFromFile(resolveExprPath(lookupFileArg(state, *i)));
|
2007-01-13 13:25:30 -05:00
|
|
|
processExpr(state, attrPaths, parseOnly, strict, autoArgs,
|
2010-03-31 08:38:31 -04:00
|
|
|
evalOnly, xmlOutput, xmlOutputSourceLocation, e);
|
2003-10-29 10:05:18 -05:00
|
|
|
}
|
2003-10-31 12:09:31 -05:00
|
|
|
|
2010-03-30 11:18:20 -04:00
|
|
|
state.printStats();
|
2003-10-29 10:05:18 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-11-18 07:06:07 -05:00
|
|
|
string programId = "nix-instantiate";
|