nix-super/src/nix-instantiate/nix-instantiate.cc

197 lines
6.4 KiB
C++
Raw Normal View History

2003-10-29 17:05:18 +02:00
#include "globals.hh"
#include "shared.hh"
#include "eval.hh"
#include "eval-inline.hh"
#include "get-drvs.hh"
#include "attr-path.hh"
2010-04-07 16:59:45 +03:00
#include "value-to-xml.hh"
#include "value-to-json.hh"
#include "util.hh"
#include "store-api.hh"
#include "local-fs-store.hh"
#include "common-eval-args.hh"
#include "legacy.hh"
#include <map>
#include <iostream>
using namespace nix;
static Path gcRoot;
static int rootNr = 0;
2014-06-27 12:36:23 +03:00
enum OutputKind { okPlain, okXML, okJSON };
2016-02-11 17:14:42 +02:00
void processExpr(EvalState & state, const Strings & attrPaths,
bool parseOnly, bool strict, Bindings & autoArgs,
bool evalOnly, OutputKind output, bool location, Expr * e)
{
2013-09-03 14:04:21 +03:00
if (parseOnly) {
2010-04-13 01:03:27 +03:00
std::cout << format("%1%\n") % *e;
2013-09-03 14:04:21 +03:00
return;
}
Value vRoot;
state.eval(e, vRoot);
2015-07-17 20:24:28 +03:00
for (auto & i : attrPaths) {
Value & v(*findAlongAttrPath(state, i, autoArgs, vRoot).first);
2022-02-04 01:31:33 +02:00
state.forceValue(v, [&]() { return v.determinePos(noPos); });
2013-09-03 14:04:21 +03:00
PathSet context;
if (evalOnly) {
Value vRes;
if (autoArgs.empty())
vRes = v;
else
state.autoCallFunction(autoArgs, v, vRes);
2014-06-27 12:36:23 +03:00
if (output == okXML)
printValueAsXML(state, strict, location, vRes, std::cout, context, noPos);
2014-06-27 12:36:23 +03:00
else if (output == okJSON)
printValueAsJSON(state, strict, vRes, v.determinePos(noPos), std::cout, context);
2010-04-07 16:59:45 +03:00
else {
if (strict) state.forceValueDeep(vRes);
std::cout << vRes << std::endl;
2013-09-03 14:04:21 +03:00
}
} else {
2013-09-03 14:04:21 +03:00
DrvInfos drvs;
getDerivations(state, v, "", autoArgs, drvs, false);
2015-07-17 20:24:28 +03:00
for (auto & i : drvs) {
auto drvPath = i.requireDrvPath();
auto drvPathS = state.store->printStorePath(drvPath);
2013-09-03 14:04:21 +03:00
/* What output do we want? */
std::string outputName = i.queryOutputName();
2013-09-03 14:04:21 +03:00
if (outputName == "")
throw Error("derivation '%1%' lacks an 'outputName' attribute", drvPathS);
2013-09-03 14:04:21 +03:00
if (gcRoot == "")
printGCWarning();
else {
Path rootName = absPath(gcRoot);
2015-10-29 14:26:55 +02:00
if (++rootNr > 1) rootName += "-" + std::to_string(rootNr);
auto store2 = state.store.dynamic_pointer_cast<LocalFSStore>();
if (store2)
drvPathS = store2->addPermRoot(drvPath, rootName);
}
std::cout << fmt("%s%s\n", drvPathS, (outputName != "out" ? "!" + outputName : ""));
2010-03-31 18:38:03 +03:00
}
}
2013-09-03 14:04:21 +03:00
}
}
static int main_nix_instantiate(int argc, char * * argv)
2003-10-29 17:05:18 +02:00
{
{
Strings files;
2014-08-13 04:50:44 +03: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;
RepairFlag repair = NoRepair;
2014-08-13 04:50:44 +03:00
struct MyArgs : LegacyArgs, MixEvalArgs
{
using LegacyArgs::LegacyArgs;
};
MyArgs myArgs(std::string(baseNameOf(argv[0])), [&](Strings::iterator & arg, const Strings::iterator & end) {
2014-08-13 04:50:44 +03: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")
;
2014-08-13 04:50:44 +03:00
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")
repair = Repair;
2014-08-13 04:50:44 +03: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 17:05:18 +02:00
myArgs.parseCmdline(argvToStrings(argc, argv));
if (evalOnly && !wantsReadWrite)
settings.readOnlyMode = true;
auto store = openStore();
auto evalStore = myArgs.evalStoreUrl ? openStore(*myArgs.evalStoreUrl) : store;
2021-07-27 12:16:47 +03:00
auto state = std::make_unique<EvalState>(myArgs.searchPath, evalStore, store);
state->repair = repair;
Bindings & autoArgs = *myArgs.getAutoArgs(*state);
if (attrPaths.empty()) attrPaths = {""};
2014-08-13 04:50:44 +03:00
if (findFile) {
2015-07-17 20:24:28 +03:00
for (auto & i : files) {
Path p = state->findFile(i);
if (p == "") throw Error("unable to find '%1%'", i);
2014-08-13 04:50:44 +03:00
std::cout << p << std::endl;
}
return 0;
}
2014-08-13 04:50:44 +03:00
if (readStdin) {
Expr * e = state->parseStdin();
processExpr(*state, attrPaths, parseOnly, strict, autoArgs,
2014-08-13 04:50:44 +03:00
evalOnly, outputKind, xmlOutputSourceLocation, e);
} else if (files.empty() && !fromArgs)
files.push_back("./default.nix");
2003-10-29 17:05:18 +02:00
for (auto & i : files) {
2014-08-13 04:50:44 +03:00
Expr * e = fromArgs
? state->parseExprFromString(i, absPath("."))
: state->parseExprFromFile(resolveExprPath(state->checkSourcePath(lookupFileArg(*state, i))));
processExpr(*state, attrPaths, parseOnly, strict, autoArgs,
2014-08-13 04:50:44 +03:00
evalOnly, outputKind, xmlOutputSourceLocation, e);
}
2003-10-29 17:05:18 +02:00
state->printStats();
return 0;
}
2014-08-13 04:50:44 +03:00
}
static RegisterLegacyCommand r_nix_instantiate("nix-instantiate", main_nix_instantiate);