tvl-depot/nix-repl.cc

699 lines
20 KiB
C++
Raw Normal View History

#include <iostream>
#include <cstdlib>
#include <setjmp.h>
#include <readline/readline.h>
#include <readline/history.h>
#include "shared.hh"
#include "eval.hh"
#include "eval-inline.hh"
#include "store-api.hh"
#include "common-opts.hh"
2013-09-06 14:58:53 +02:00
#include "get-drvs.hh"
#include "derivations.hh"
2013-09-06 21:00:36 +02:00
#include "affinity.hh"
#include "globals.hh"
using namespace std;
using namespace nix;
struct NixRepl
{
string curDir;
EvalState state;
2013-09-09 16:02:46 +02:00
Strings loadedFiles;
2013-09-09 17:06:14 +02:00
const static int envSize = 32768;
StaticEnv staticEnv;
Env * env;
int displ;
2013-09-06 19:51:59 +02:00
StringSet varNames;
StringSet completions;
StringSet::iterator curCompletion;
NixRepl(const Strings & searchPath, nix::ref<Store> store);
void mainLoop(const Strings & files);
2013-09-06 19:51:59 +02:00
void completePrefix(string prefix);
2016-02-18 13:50:52 +01:00
bool getLine(string & input, const char * prompt);
Path getDerivationPath(Value & v);
2013-09-09 15:02:56 +02:00
bool processLine(string line);
void loadFile(const Path & path);
2013-09-09 17:06:14 +02:00
void initEnv();
2013-09-09 16:02:46 +02:00
void reloadFiles();
void addAttrsToScope(Value & attrs);
void addVarToScope(const Symbol & name, Value & v);
Expr * parseString(string s);
void evalString(string s, Value & v);
typedef set<Value *> ValuesSeen;
std::ostream & printValue(std::ostream & str, Value & v, unsigned int maxDepth);
std::ostream & printValue(std::ostream & str, Value & v, unsigned int maxDepth, ValuesSeen & seen);
};
void printHelp()
{
cout << "Usage: nix-repl [--help] [--version] [-I path] paths...\n"
<< "\n"
<< "nix-repl is a simple read-eval-print loop (REPL) for the Nix package manager.\n"
<< "\n"
<< "Options:\n"
<< " --help\n"
<< " Prints out a summary of the command syntax and exits.\n"
<< "\n"
<< " --version\n"
<< " Prints out the Nix version number on standard output and exits.\n"
<< "\n"
<< " -I path\n"
<< " Add a path to the Nix expression search path. This option may be given\n"
<< " multiple times. See the NIX_PATH environment variable for information on\n"
<< " the semantics of the Nix search path. Paths added through -I take\n"
<< " precedence over NIX_PATH.\n"
<< "\n"
<< " paths...\n"
<< " A list of paths to files containing Nix expressions which nix-repl will\n"
<< " load and add to its scope.\n"
<< "\n"
<< " A path surrounded in < and > will be looked up in the Nix expression search\n"
<< " path, as in the Nix language itself.\n"
<< "\n"
<< " If an element of paths starts with http:// or https://, it is interpreted\n"
<< " as the URL of a tarball that will be downloaded and unpacked to a temporary\n"
<< " location. The tarball must include a single top-level directory containing\n"
<< " at least a file named default.nix.\n"
<< flush;
}
string removeWhitespace(string s)
{
s = chomp(s);
size_t n = s.find_first_not_of(" \n\r\t");
if (n != string::npos) s = string(s, n);
return s;
}
NixRepl::NixRepl(const Strings & searchPath, nix::ref<Store> store)
: state(searchPath, store)
, staticEnv(false, &state.staticBaseEnv)
{
curDir = absPath(".");
}
void NixRepl::mainLoop(const Strings & files)
{
string error = ANSI_RED "error:" ANSI_NORMAL " ";
std::cout << "Welcome to Nix version " << NIX_VERSION << ". Type :? for help." << std::endl << std::endl;
for (auto & i : files)
loadedFiles.push_back(i);
2013-09-09 16:02:46 +02:00
2013-09-09 17:06:14 +02:00
reloadFiles();
if (!loadedFiles.empty()) std::cout << std::endl;
2013-09-06 13:14:28 +02:00
using_history();
read_history(0);
string input;
while (true) {
2016-02-18 14:04:55 +01:00
// When continuing input from previous lines, don't print a prompt, just align to the same
// number of chars as the prompt.
const char * prompt = input.empty() ? "nix-repl> " : " ";
2016-02-18 13:50:52 +01:00
if (!getLine(input, prompt)) {
2013-09-09 15:02:56 +02:00
std::cout << std::endl;
break;
}
try {
if (!removeWhitespace(input).empty() && !processLine(input)) return;
} catch (ParseError & e) {
if (e.msg().find("unexpected $end") != std::string::npos) {
// For parse errors on incomplete input, we continue waiting for the next line of
// input without clearing the input so far.
continue;
} else {
printMsg(lvlError, format(error + "%1%%2%") % (settings.showTrace ? e.prefix() : "") % e.msg());
}
} catch (Error & e) {
printMsg(lvlError, format(error + "%1%%2%") % (settings.showTrace ? e.prefix() : "") % e.msg());
} catch (Interrupted & e) {
printMsg(lvlError, format(error + "%1%%2%") % (settings.showTrace ? e.prefix() : "") % e.msg());
}
// We handled the current input fully, so we should clear it and read brand new input.
input.clear();
std::cout << std::endl;
}
}
2013-09-06 19:51:59 +02:00
/* Apparently, the only way to get readline() to return on Ctrl-C
(SIGINT) is to use siglongjmp(). That's fucked up... */
static sigjmp_buf sigintJmpBuf;
static void sigintHandler(int signo)
{
siglongjmp(sigintJmpBuf, 1);
}
/* Oh, if only g++ had nested functions... */
NixRepl * curRepl;
char * completerThunk(const char * s, int state)
{
string prefix(s);
/* If the prefix has a slash in it, use readline's builtin filename
completer. */
if (prefix.find('/') != string::npos)
return rl_filename_completion_function(s, state);
/* Otherwise, return all symbols that start with the prefix. */
if (state == 0) {
curRepl->completePrefix(s);
curRepl->curCompletion = curRepl->completions.begin();
}
if (curRepl->curCompletion == curRepl->completions.end()) return 0;
return strdup((curRepl->curCompletion++)->c_str());
}
2016-02-18 13:50:52 +01:00
bool NixRepl::getLine(string & input, const char * prompt)
2013-09-06 19:51:59 +02:00
{
struct sigaction act, old;
act.sa_handler = sigintHandler;
sigfillset(&act.sa_mask);
act.sa_flags = 0;
if (sigaction(SIGINT, &act, &old))
throw SysError("installing handler for SIGINT");
2016-02-18 13:50:52 +01:00
if (sigsetjmp(sigintJmpBuf, 1)) {
input.clear();
} else {
2013-09-06 19:51:59 +02:00
curRepl = this;
rl_completion_entry_function = completerThunk;
char * s = readline(prompt);
2013-09-06 19:51:59 +02:00
if (!s) return false;
input.append(s);
2016-02-18 13:50:52 +01:00
input.push_back('\n');
if (!removeWhitespace(s).empty()) {
add_history(s);
2013-09-06 19:51:59 +02:00
append_history(1, 0);
}
free(s);
2013-09-06 19:51:59 +02:00
}
_isInterrupted = 0;
if (sigaction(SIGINT, &old, 0))
throw SysError("restoring handler for SIGINT");
return true;
}
void NixRepl::completePrefix(string prefix)
{
completions.clear();
size_t dot = prefix.rfind('.');
if (dot == string::npos) {
/* This is a variable name; look it up in the current scope. */
StringSet::iterator i = varNames.lower_bound(prefix);
while (i != varNames.end()) {
if (string(*i, 0, prefix.size()) != prefix) break;
completions.insert(*i);
i++;
}
} else {
try {
/* This is an expression that should evaluate to an
attribute set. Evaluate it to get the names of the
attributes. */
string expr(prefix, 0, dot);
string prefix2 = string(prefix, dot + 1);
Expr * e = parseString(expr);
Value v;
e->eval(state, *env, v);
state.forceAttrs(v);
for (auto & i : *v.attrs) {
string name = i.name;
if (string(name, 0, prefix2.size()) != prefix2) continue;
completions.insert(expr + "." + name);
}
} catch (ParseError & e) {
// Quietly ignore parse errors.
} catch (EvalError & e) {
// Quietly ignore evaluation errors.
} catch (UndefinedVarError & e) {
// Quietly ignore undefined variable errors.
}
2013-09-06 19:51:59 +02:00
}
}
2013-09-06 21:00:36 +02:00
static int runProgram(const string & program, const Strings & args)
{
std::vector<const char *> cargs; /* careful with c_str()! */
cargs.push_back(program.c_str());
for (Strings::const_iterator i = args.begin(); i != args.end(); ++i)
cargs.push_back(i->c_str());
cargs.push_back(0);
Pid pid;
pid = fork();
if (pid == -1) throw SysError("forking");
if (pid == 0) {
restoreAffinity();
execvp(program.c_str(), (char * *) &cargs[0]);
_exit(1);
}
return pid.wait(true);
}
bool isVarName(const string & s)
{
if (s.size() == 0) return false;
char c = s[0];
if ((c >= '0' && c <= '9') || c == '-' || c == '\'') return false;
for (auto & i : s)
if (!((i >= 'a' && i <= 'z') ||
(i >= 'A' && i <= 'Z') ||
(i >= '0' && i <= '9') ||
i == '_' || i == '-' || i == '\''))
return false;
return true;
}
Path NixRepl::getDerivationPath(Value & v) {
DrvInfo drvInfo(state);
if (!getDerivation(state, v, drvInfo, false))
throw Error("expression does not evaluate to a derivation, so I can't build it");
Path drvPath = drvInfo.queryDrvPath();
if (drvPath == "" || !state.store->isValidPath(drvPath))
throw Error("expression did not evaluate to a valid derivation");
return drvPath;
}
2013-09-09 15:02:56 +02:00
bool NixRepl::processLine(string line)
{
2013-09-09 15:02:56 +02:00
if (line == "") return true;
string command, arg;
2013-09-09 15:02:56 +02:00
if (line[0] == ':') {
2016-02-18 13:59:51 +01:00
size_t p = line.find_first_of(" \n\r\t");
2013-09-09 15:02:56 +02:00
command = string(line, 0, p);
if (p != string::npos) arg = removeWhitespace(string(line, p));
} else {
arg = line;
}
2013-09-09 16:02:46 +02:00
if (command == ":?" || command == ":help") {
2013-09-09 13:22:33 +02:00
cout << "The following commands are available:\n"
<< "\n"
<< " <expr> Evaluate and print expression\n"
<< " <x> = <expr> Bind expression to variable\n"
<< " :a <expr> Add attributes from resulting set to scope\n"
<< " :b <expr> Build derivation\n"
<< " :i <expr> Build derivation, then install result into current profile\n"
<< " :l <path> Load Nix expression and add it to scope\n"
<< " :p <expr> Evaluate and print expression recursively\n"
2013-09-09 15:02:56 +02:00
<< " :q Exit nix-repl\n"
2013-09-09 16:02:46 +02:00
<< " :r Reload all files\n"
<< " :s <expr> Build dependencies of derivation, then start nix-shell\n"
<< " :t <expr> Describe result of evaluation\n"
2016-02-19 11:00:36 +01:00
<< " :u <expr> Build derivation, then start nix-shell\n";
2013-09-09 13:22:33 +02:00
}
2013-09-09 16:02:46 +02:00
else if (command == ":a" || command == ":add") {
Value v;
2013-09-09 15:02:56 +02:00
evalString(arg, v);
addAttrsToScope(v);
}
2013-09-09 16:02:46 +02:00
else if (command == ":l" || command == ":load") {
state.resetFileCache();
2013-09-09 15:02:56 +02:00
loadFile(arg);
}
2013-09-09 16:02:46 +02:00
else if (command == ":r" || command == ":reload") {
state.resetFileCache();
reloadFiles();
}
else if (command == ":t") {
Value v;
2013-09-09 15:02:56 +02:00
evalString(arg, v);
std::cout << showType(v) << std::endl;
2016-02-19 11:00:36 +01:00
} else if (command == ":u") {
Value v, f, result;
evalString(arg, v);
evalString("drv: (import <nixpkgs> {}).runCommand \"shell\" { buildInputs = [ drv ]; } \"\"", f);
state.callFunction(f, v, result, Pos());
Path drvPath = getDerivationPath(result);
runProgram("nix-shell", Strings{drvPath});
}
else if (command == ":b" || command == ":i" || command == ":s") {
2013-09-06 14:58:53 +02:00
Value v;
2013-09-09 15:02:56 +02:00
evalString(arg, v);
Path drvPath = getDerivationPath(v);
if (command == ":b") {
/* We could do the build in this process using buildPaths(),
but doing it in a child makes it easier to recover from
problems / SIGINT. */
2013-09-09 15:02:56 +02:00
if (runProgram("nix-store", Strings{"-r", drvPath}) == 0) {
2014-04-11 12:50:46 +02:00
Derivation drv = readDerivation(drvPath);
2013-09-09 15:02:56 +02:00
std::cout << std::endl << "this derivation produced the following outputs:" << std::endl;
for (auto & i : drv.outputs)
std::cout << format(" %1% -> %2%") % i.first % i.second.path << std::endl;
2013-09-09 15:02:56 +02:00
}
} else if (command == ":i") {
runProgram("nix-env", Strings{"-i", drvPath});
} else {
2013-09-06 21:00:36 +02:00
runProgram("nix-shell", Strings{drvPath});
}
}
2013-09-09 16:02:46 +02:00
else if (command == ":p" || command == ":print") {
Value v;
2013-09-09 15:02:56 +02:00
evalString(arg, v);
printValue(std::cout, v, 1000000000) << std::endl;
}
2013-09-09 15:02:56 +02:00
else if (command == ":q" || command == ":quit")
return false;
else if (command != "")
throw Error(format("unknown command %1%") % command);
2013-09-06 14:58:53 +02:00
else {
size_t p = line.find('=');
string name;
if (p != string::npos &&
p < line.size() &&
line[p + 1] != '=' &&
isVarName(name = removeWhitespace(string(line, 0, p))))
{
Expr * e = parseString(string(line, p + 1));
Value & v(*state.allocValue());
v.type = tThunk;
v.thunk.env = env;
v.thunk.expr = e;
addVarToScope(state.symbols.create(name), v);
} else {
Value v;
evalString(line, v);
printValue(std::cout, v, 1) << std::endl;
}
}
2013-09-09 15:02:56 +02:00
return true;
}
void NixRepl::loadFile(const Path & path)
{
2013-09-09 16:02:46 +02:00
loadedFiles.remove(path);
loadedFiles.push_back(path);
Value v, v2;
state.evalFile(lookupFileArg(state, path), v);
Bindings & bindings(*state.allocBindings(0));
state.autoCallFunction(bindings, v, v2);
addAttrsToScope(v2);
}
2013-09-09 17:06:14 +02:00
void NixRepl::initEnv()
{
env = &state.allocEnv(envSize);
env->up = &state.baseEnv;
displ = 0;
staticEnv.vars.clear();
2013-09-09 17:22:42 +02:00
varNames.clear();
for (auto & i : state.staticBaseEnv.vars)
varNames.insert(i.first);
2013-09-09 17:06:14 +02:00
}
2013-09-09 16:02:46 +02:00
void NixRepl::reloadFiles()
{
2013-09-09 17:06:14 +02:00
initEnv();
2013-09-09 16:02:46 +02:00
Strings old = loadedFiles;
loadedFiles.clear();
bool first = true;
for (auto & i : old) {
if (!first) std::cout << std::endl;
first = false;
std::cout << format("Loading %1%...") % i << std::endl;
loadFile(i);
2013-09-09 16:02:46 +02:00
}
}
void NixRepl::addAttrsToScope(Value & attrs)
{
state.forceAttrs(attrs);
for (auto & i : *attrs.attrs)
addVarToScope(i.name, *i.value);
std::cout << format("Added %1% variables.") % attrs.attrs->size() << std::endl;
}
void NixRepl::addVarToScope(const Symbol & name, Value & v)
{
2013-09-09 17:06:14 +02:00
if (displ >= envSize)
throw Error("environment full; cannot add more variables");
staticEnv.vars[name] = displ;
env->values[displ++] = &v;
2013-09-06 19:51:59 +02:00
varNames.insert((string) name);
}
Expr * NixRepl::parseString(string s)
{
Expr * e = state.parseExprFromString(s, curDir, staticEnv);
return e;
}
void NixRepl::evalString(string s, Value & v)
{
Expr * e = parseString(s);
e->eval(state, *env, v);
state.forceValue(v);
}
std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int maxDepth)
{
ValuesSeen seen;
return printValue(str, v, maxDepth, seen);
}
std::ostream & printStringValue(std::ostream & str, const char * string) {
str << "\"";
for (const char * i = string; *i; i++)
if (*i == '\"' || *i == '\\') str << "\\" << *i;
else if (*i == '\n') str << "\\n";
else if (*i == '\r') str << "\\r";
else if (*i == '\t') str << "\\t";
else str << *i;
str << "\"";
return str;
}
// FIXME: lot of cut&paste from Nix's eval.cc.
std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int maxDepth, ValuesSeen & seen)
{
str.flush();
checkInterrupt();
state.forceValue(v);
switch (v.type) {
case tInt:
str << v.integer;
break;
case tBool:
str << (v.boolean ? "true" : "false");
break;
case tString:
printStringValue(str, v.string.s);
break;
case tPath:
str << v.path; // !!! escaping?
break;
case tNull:
str << "null";
break;
case tAttrs: {
seen.insert(&v);
bool isDrv = state.isDerivation(v);
2014-01-28 10:40:02 +01:00
if (isDrv) {
str << "«derivation ";
Bindings::iterator i = v.attrs->find(state.sDrvPath);
PathSet context;
2014-04-11 12:50:46 +02:00
Path drvPath = i != v.attrs->end() ? state.coerceToPath(*i->pos, *i->value, context) : "???";
2014-01-28 10:40:02 +01:00
str << drvPath << "»";
}
else if (maxDepth > 0) {
str << "{ ";
typedef std::map<string, Value *> Sorted;
Sorted sorted;
for (auto & i : *v.attrs)
sorted[i.name] = i.value;
/* If this is a derivation, then don't show the
self-references ("all", "out", etc.). */
StringSet hidden;
if (isDrv) {
hidden.insert("all");
Bindings::iterator i = v.attrs->find(state.sOutputs);
if (i == v.attrs->end())
hidden.insert("out");
else {
state.forceList(*i->value);
for (unsigned int j = 0; j < i->value->listSize(); ++j)
hidden.insert(state.forceStringNoCtx(*i->value->listElems()[j]));
}
}
for (auto & i : sorted) {
if (isVarName(i.first))
str << i.first;
else
printStringValue(str, i.first.c_str());
str << " = ";
if (hidden.find(i.first) != hidden.end())
str << "«...»";
else if (seen.find(i.second) != seen.end())
str << "«repeated»";
else
try {
printValue(str, *i.second, maxDepth - 1, seen);
} catch (AssertionError & e) {
str << "«error: " << e.msg() << "»";
}
str << "; ";
}
2014-01-28 10:40:02 +01:00
str << "}";
} else
2014-01-28 10:40:02 +01:00
str << "{ ... }";
break;
}
case tList1:
case tList2:
case tListN:
seen.insert(&v);
str << "[ ";
if (maxDepth > 0)
for (unsigned int n = 0; n < v.listSize(); ++n) {
if (seen.find(v.listElems()[n]) != seen.end())
str << "«repeated»";
else
try {
printValue(str, *v.listElems()[n], maxDepth - 1, seen);
} catch (AssertionError & e) {
str << "«error: " << e.msg() << "»";
}
str << " ";
}
else
str << "... ";
str << "]";
break;
case tLambda:
str << "«lambda»";
break;
case tPrimOp:
str << "«primop»";
break;
case tPrimOpApp:
str << "«primop-app»";
break;
default:
str << "«unknown»";
break;
}
return str;
}
int main(int argc, char * * argv)
{
return handleExceptions(argv[0], [&]() {
initNix();
initGC();
2014-08-26 20:05:08 +02:00
Strings files, searchPath;
parseCmdLine(argc, argv, [&](Strings::iterator & arg, const Strings::iterator & end) {
if (*arg == "--version")
printVersion("nix-repl");
else if (*arg == "--help") {
printHelp();
// exit with 0 since user asked for help
_exit(0);
}
2014-08-26 20:05:08 +02:00
else if (parseSearchPathArg(arg, end, searchPath))
;
else if (*arg != "" && arg->at(0) == '-')
return false;
else
files.push_back(*arg);
return true;
});
NixRepl repl(searchPath, openStore());
repl.mainLoop(files);
});
}