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"
|
2014-06-23 17:30:22 -04:00
|
|
|
#include "value-to-json.hh"
|
2006-09-04 17:06:23 -04:00
|
|
|
#include "util.hh"
|
2006-11-30 12:43:04 -05:00
|
|
|
#include "store-api.hh"
|
2017-10-24 06:45:11 -04:00
|
|
|
#include "common-eval-args.hh"
|
2018-10-26 05:35:46 -04:00
|
|
|
#include "legacy.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;
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
2014-06-27 05:36:23 -04:00
|
|
|
enum OutputKind { okPlain, okXML, okJSON };
|
|
|
|
|
|
|
|
|
2016-02-11 10:14:42 -05:00
|
|
|
void processExpr(EvalState & state, const Strings & attrPaths,
|
2010-10-22 10:47:42 -04:00
|
|
|
bool parseOnly, bool strict, Bindings & autoArgs,
|
2014-06-23 17:30:22 -04:00
|
|
|
bool evalOnly, OutputKind output, 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);
|
|
|
|
|
2015-07-17 13:24:28 -04:00
|
|
|
for (auto & i : attrPaths) {
|
|
|
|
Value & v(*findAlongAttrPath(state, i, autoArgs, vRoot));
|
2013-09-03 07:04:21 -04:00
|
|
|
state.forceValue(v);
|
|
|
|
|
|
|
|
PathSet context;
|
2014-05-13 06:54:28 -04:00
|
|
|
if (evalOnly) {
|
|
|
|
Value vRes;
|
|
|
|
if (autoArgs.empty())
|
|
|
|
vRes = v;
|
|
|
|
else
|
|
|
|
state.autoCallFunction(autoArgs, v, vRes);
|
2014-06-27 05:36:23 -04:00
|
|
|
if (output == okXML)
|
2014-05-13 06:54:28 -04:00
|
|
|
printValueAsXML(state, strict, location, vRes, std::cout, context);
|
2014-06-27 05:36:23 -04:00
|
|
|
else if (output == okJSON)
|
2014-06-23 17:30:22 -04:00
|
|
|
printValueAsJSON(state, strict, vRes, std::cout, context);
|
2010-04-07 09:59:45 -04:00
|
|
|
else {
|
2014-09-22 09:03:59 -04:00
|
|
|
if (strict) state.forceValueDeep(vRes);
|
2014-05-13 06:54:28 -04:00
|
|
|
std::cout << vRes << std::endl;
|
2013-09-03 07:04:21 -04:00
|
|
|
}
|
2014-05-13 06:54:28 -04:00
|
|
|
} else {
|
2013-09-03 07:04:21 -04:00
|
|
|
DrvInfos drvs;
|
|
|
|
getDerivations(state, v, "", autoArgs, drvs, false);
|
2015-07-17 13:24:28 -04:00
|
|
|
for (auto & i : drvs) {
|
|
|
|
Path drvPath = i.queryDrvPath();
|
2013-09-03 07:04:21 -04:00
|
|
|
|
|
|
|
/* What output do we want? */
|
2015-07-17 13:24:28 -04:00
|
|
|
string outputName = i.queryOutputName();
|
2013-09-03 07:04:21 -04:00
|
|
|
if (outputName == "")
|
2017-07-30 07:27:57 -04:00
|
|
|
throw Error(format("derivation '%1%' lacks an 'outputName' attribute ") % drvPath);
|
2013-09-03 07:04:21 -04:00
|
|
|
|
|
|
|
if (gcRoot == "")
|
|
|
|
printGCWarning();
|
|
|
|
else {
|
2018-03-16 18:15:24 -04:00
|
|
|
Path rootName = indirectRoot ? absPath(gcRoot) : gcRoot;
|
2015-10-29 08:26:55 -04:00
|
|
|
if (++rootNr > 1) rootName += "-" + std::to_string(rootNr);
|
2016-06-02 07:33:49 -04:00
|
|
|
auto store2 = state.store.dynamic_pointer_cast<LocalFSStore>();
|
|
|
|
if (store2)
|
|
|
|
drvPath = store2->addPermRoot(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
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-10-26 05:35:46 -04:00
|
|
|
static int _main(int argc, char * * argv)
|
2003-10-29 10:05:18 -05:00
|
|
|
{
|
2018-10-26 05:35:46 -04:00
|
|
|
{
|
2017-10-24 06:45:11 -04:00
|
|
|
Strings files;
|
2014-08-12 21:50:44 -04:00
|
|
|
bool readStdin = false;
|
|
|
|
bool fromArgs = false;
|
|
|
|
bool findFile = false;
|
|
|
|
bool evalOnly = false;
|
|
|
|
bool parseOnly = false;
|
|
|
|
OutputKind outputKind = okPlain;
|
|
|
|
bool xmlOutputSourceLocation = true;
|
|
|
|
bool strict = false;
|
|
|
|
Strings attrPaths;
|
|
|
|
bool wantsReadWrite = false;
|
2017-06-28 12:11:01 -04:00
|
|
|
RepairFlag repair = NoRepair;
|
2014-08-12 21:50:44 -04:00
|
|
|
|
2017-10-24 06:45:11 -04:00
|
|
|
struct MyArgs : LegacyArgs, MixEvalArgs
|
|
|
|
{
|
|
|
|
using LegacyArgs::LegacyArgs;
|
|
|
|
};
|
|
|
|
|
|
|
|
MyArgs myArgs(baseNameOf(argv[0]), [&](Strings::iterator & arg, const Strings::iterator & end) {
|
2014-08-12 21:50:44 -04:00
|
|
|
if (*arg == "--help")
|
|
|
|
showManPage("nix-instantiate");
|
|
|
|
else if (*arg == "--version")
|
|
|
|
printVersion("nix-instantiate");
|
|
|
|
else if (*arg == "-")
|
|
|
|
readStdin = true;
|
|
|
|
else if (*arg == "--expr" || *arg == "-E")
|
|
|
|
fromArgs = true;
|
|
|
|
else if (*arg == "--eval" || *arg == "--eval-only")
|
|
|
|
evalOnly = true;
|
|
|
|
else if (*arg == "--read-write-mode")
|
|
|
|
wantsReadWrite = true;
|
|
|
|
else if (*arg == "--parse" || *arg == "--parse-only")
|
|
|
|
parseOnly = evalOnly = true;
|
|
|
|
else if (*arg == "--find-file")
|
|
|
|
findFile = true;
|
|
|
|
else if (*arg == "--attr" || *arg == "-A")
|
|
|
|
attrPaths.push_back(getArg(*arg, arg, end));
|
|
|
|
else if (*arg == "--add-root")
|
|
|
|
gcRoot = getArg(*arg, arg, end);
|
|
|
|
else if (*arg == "--indirect")
|
|
|
|
indirectRoot = true;
|
|
|
|
else if (*arg == "--xml")
|
|
|
|
outputKind = okXML;
|
|
|
|
else if (*arg == "--json")
|
|
|
|
outputKind = okJSON;
|
|
|
|
else if (*arg == "--no-location")
|
|
|
|
xmlOutputSourceLocation = false;
|
|
|
|
else if (*arg == "--strict")
|
|
|
|
strict = true;
|
|
|
|
else if (*arg == "--repair")
|
2017-06-28 12:11:01 -04:00
|
|
|
repair = Repair;
|
2014-08-12 21:50:44 -04:00
|
|
|
else if (*arg == "--dry-run")
|
|
|
|
settings.readOnlyMode = true;
|
|
|
|
else if (*arg != "" && arg->at(0) == '-')
|
|
|
|
return false;
|
|
|
|
else
|
|
|
|
files.push_back(*arg);
|
|
|
|
return true;
|
|
|
|
});
|
2003-10-29 10:05:18 -05:00
|
|
|
|
2017-10-24 06:45:11 -04:00
|
|
|
myArgs.parseCmdline(argvToStrings(argc, argv));
|
|
|
|
|
2018-02-08 11:26:18 -05:00
|
|
|
initPlugins();
|
|
|
|
|
2015-05-05 11:09:42 -04:00
|
|
|
if (evalOnly && !wantsReadWrite)
|
|
|
|
settings.readOnlyMode = true;
|
|
|
|
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 08:28:26 -05:00
|
|
|
auto store = openStore();
|
2015-05-05 11:09:42 -04:00
|
|
|
|
2018-06-12 11:26:36 -04:00
|
|
|
auto state = std::make_unique<EvalState>(myArgs.searchPath, store);
|
|
|
|
state->repair = repair;
|
2014-02-04 10:37:10 -05:00
|
|
|
|
2018-06-12 11:26:36 -04:00
|
|
|
Bindings & autoArgs = *myArgs.getAutoArgs(*state);
|
2007-01-13 13:25:30 -05:00
|
|
|
|
2017-07-25 09:09:06 -04:00
|
|
|
if (attrPaths.empty()) attrPaths = {""};
|
2014-08-12 21:50:44 -04:00
|
|
|
|
|
|
|
if (findFile) {
|
2015-07-17 13:24:28 -04:00
|
|
|
for (auto & i : files) {
|
2018-06-12 11:26:36 -04:00
|
|
|
Path p = state->findFile(i);
|
2017-07-30 07:27:57 -04:00
|
|
|
if (p == "") throw Error(format("unable to find '%1%'") % i);
|
2014-08-12 21:50:44 -04:00
|
|
|
std::cout << p << std::endl;
|
|
|
|
}
|
2018-10-26 05:35:46 -04:00
|
|
|
return 0;
|
2012-04-17 11:14:14 -04:00
|
|
|
}
|
|
|
|
|
2014-08-12 21:50:44 -04:00
|
|
|
if (readStdin) {
|
2018-06-12 11:26:36 -04:00
|
|
|
Expr * e = state->parseStdin();
|
|
|
|
processExpr(*state, attrPaths, parseOnly, strict, autoArgs,
|
2014-08-12 21:50:44 -04:00
|
|
|
evalOnly, outputKind, xmlOutputSourceLocation, e);
|
|
|
|
} else if (files.empty() && !fromArgs)
|
|
|
|
files.push_back("./default.nix");
|
2003-10-29 10:05:18 -05:00
|
|
|
|
2015-05-06 08:54:31 -04:00
|
|
|
for (auto & i : files) {
|
2014-08-12 21:50:44 -04:00
|
|
|
Expr * e = fromArgs
|
2018-06-12 11:26:36 -04:00
|
|
|
? state->parseExprFromString(i, absPath("."))
|
|
|
|
: state->parseExprFromFile(resolveExprPath(state->checkSourcePath(lookupFileArg(*state, i))));
|
|
|
|
processExpr(*state, attrPaths, parseOnly, strict, autoArgs,
|
2014-08-12 21:50:44 -04:00
|
|
|
evalOnly, outputKind, xmlOutputSourceLocation, e);
|
|
|
|
}
|
2003-10-29 10:05:18 -05:00
|
|
|
|
2018-06-12 11:26:36 -04:00
|
|
|
state->printStats();
|
2018-10-26 05:35:46 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-08-12 21:50:44 -04:00
|
|
|
}
|
2018-10-26 05:35:46 -04:00
|
|
|
|
|
|
|
static RegisterLegacyCommand s1("nix-instantiate", _main);
|