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

198 lines
6.3 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 "common-opts.hh"
#include <map>
#include <iostream>
using namespace nix;
static Expr * parseStdin(EvalState & state)
2003-10-29 17:05:18 +02:00
{
2017-05-16 17:09:57 +03:00
//Activity act(*logger, lvlTalkative, format("parsing standard input"));
2012-08-28 18:47:26 +03:00
return state.parseExprFromString(drainFD(0), absPath("."));
2003-10-29 17:05:18 +02:00
}
static Path gcRoot;
static int rootNr = 0;
static bool indirectRoot = false;
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));
2013-09-03 14:04:21 +03:00
state.forceValue(v);
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);
2014-06-27 12:36:23 +03:00
else if (output == okJSON)
printValueAsJSON(state, strict, vRes, 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) {
Path drvPath = i.queryDrvPath();
2013-09-03 14:04:21 +03:00
/* What output do we want? */
2015-07-17 20:24:28 +03:00
string outputName = i.queryOutputName();
2013-09-03 14:04:21 +03:00
if (outputName == "")
throw Error(format("derivation %1% lacks an outputName attribute ") % drvPath);
2013-09-03 14:04:21 +03:00
if (gcRoot == "")
printGCWarning();
else {
Path rootName = 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)
drvPath = store2->addPermRoot(drvPath, rootName, indirectRoot);
}
2013-09-03 14:04:21 +03:00
std::cout << format("%1%%2%\n") % drvPath % (outputName != "out" ? "!" + outputName : "");
2010-03-31 18:38:03 +03:00
}
}
2013-09-03 14:04:21 +03:00
}
}
2014-08-13 04:50:44 +03:00
int main(int argc, char * * argv)
2003-10-29 17:05:18 +02:00
{
2014-08-13 04:50:44 +03:00
return handleExceptions(argv[0], [&]() {
initNix();
initGC();
2014-08-13 04:50:44 +03:00
Strings files, searchPath;
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;
std::map<string, string> autoArgs_;
bool repair = false;
parseCmdLine(argc, argv, [&](Strings::iterator & arg, const Strings::iterator & end) {
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 (parseAutoArgs(arg, end, autoArgs_))
;
else if (parseSearchPathArg(arg, end, searchPath))
;
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")
repair = true;
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
if (evalOnly && !wantsReadWrite)
settings.readOnlyMode = true;
auto store = openStore();
EvalState state(searchPath, store);
2014-08-13 04:50:44 +03:00
state.repair = repair;
Bindings & autoArgs(*evalAutoArgs(state, autoArgs_));
2014-08-13 04:50:44 +03:00
if (attrPaths.empty()) attrPaths.push_back("");
if (findFile) {
2015-07-17 20:24:28 +03:00
for (auto & i : files) {
Path p = state.findFile(i);
if (p == "") throw Error(format("unable to find %1%") % i);
2014-08-13 04:50:44 +03:00
std::cout << p << std::endl;
}
return;
}
2014-08-13 04:50:44 +03:00
if (readStdin) {
Expr * e = parseStdin(state);
2016-02-11 17:14:42 +02:00
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(lookupFileArg(state, i)));
2016-02-11 17:14:42 +02:00
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
2014-08-13 04:50:44 +03:00
state.printStats();
});
}