lix/nix-repl.cc
Eelco Dolstra e133e91410 Support tab-completion on attribute sets
Example:

$ nix-repl '<nixos>'

> config.services.xserver.desktop<TAB>

comletes to

> config.services.xserver.desktopManager

You also get suggestions if there are multiple matches:

> config.services.xserver.desktopManager.kde4
config.services.xserver.desktopManager.kde4.enable
config.services.xserver.desktopManager.kde4.phononBackends
2013-09-09 12:00:33 +02:00

492 lines
12 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#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"
#include "get-drvs.hh"
#include "derivations.hh"
#include "affinity.hh"
using namespace std;
using namespace nix;
string programId = "nix-repl";
struct NixRepl
{
string curDir;
EvalState state;
StaticEnv staticEnv;
Env * env;
int displ;
StringSet varNames;
StringSet completions;
StringSet::iterator curCompletion;
NixRepl();
void mainLoop(const Strings & args);
void completePrefix(string prefix);
bool getLine(string & line);
void processLine(string line);
void loadFile(const Path & path);
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()
{
std::cout << "Usage: nix-repl\n";
}
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()
: staticEnv(false, &state.staticBaseEnv)
{
curDir = absPath(".");
env = &state.allocEnv(32768);
env->up = &state.baseEnv;
displ = 0;
store = openStore();
}
void NixRepl::mainLoop(const Strings & args)
{
std::cout << "Welcome to Nix version " << NIX_VERSION << ". Type :? for help." << std::endl << std::endl;
foreach (Strings::const_iterator, i, args) {
std::cout << format("Loading %1%...") % *i << std::endl;
loadFile(*i);
std::cout << std::endl;
}
using_history();
read_history(0);
while (true) {
string line;
if (!getLine(line)) break;
try {
processLine(removeWhitespace(line));
} catch (Error & e) {
printMsg(lvlError, "error: " + e.msg());
} catch (Interrupted & e) {
printMsg(lvlError, "error: " + e.msg());
}
std::cout << std::endl;
}
std::cout << std::endl;
}
/* 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());
}
bool NixRepl::getLine(string & line)
{
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");
if (sigsetjmp(sigintJmpBuf, 1))
line = "";
else {
curRepl = this;
rl_completion_entry_function = completerThunk;
char * s = readline("nix-repl> ");
if (!s) return false;
line = chomp(string(s));
free(s);
if (line != "") {
add_history(line.c_str());
append_history(1, 0);
}
}
_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);
foreach (Bindings::iterator, 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.
}
}
}
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);
}
void NixRepl::processLine(string line)
{
if (line == "") return;
string command = string(line, 0, 2);
if (command == ":a") {
Value v;
evalString(string(line, 2), v);
addAttrsToScope(v);
}
else if (command == ":l") {
state.resetFileCache();
loadFile(removeWhitespace(string(line, 2)));
}
else if (command == ":t") {
Value v;
evalString(string(line, 2), v);
std::cout << showType(v) << std::endl;
}
else if (command == ":b" || command == ":s") {
Value v;
evalString(string(line, 2), v);
DrvInfo drvInfo;
if (!getDerivation(state, v, drvInfo, false))
throw Error("expression does not evaluation to a derivation, so I can't build it");
Path drvPath = drvInfo.queryDrvPath(state);
if (drvPath == "" || !store->isValidPath(drvPath))
throw Error("expression did not evaluate to a valid derivation");
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. */
if (runProgram("nix-store", Strings{"-r", drvPath}) != 0) return;
Derivation drv = parseDerivation(readFile(drvPath));
std::cout << std::endl << "this derivation produced the following outputs:" << std::endl;
foreach (DerivationOutputs::iterator, i, drv.outputs)
std::cout << format(" %1% -> %2%") % i->first % i->second.path << std::endl;
} else
runProgram("nix-shell", Strings{drvPath});
}
else if (command == ":p") {
Value v;
evalString(string(line, 2), v);
printValue(std::cout, v, 1000000000) << std::endl;
}
else if (string(line, 0, 1) == ":")
throw Error(format("unknown command %1%") % string(line, 0, 2));
else {
Value v;
evalString(line, v);
printValue(std::cout, v, 1) << std::endl;
}
}
void NixRepl::loadFile(const Path & path)
{
Value v, v2;
state.evalFile(lookupFileArg(state, path), v);
Bindings bindings;
state.autoCallFunction(bindings, v, v2);
addAttrsToScope(v2);
}
void NixRepl::addAttrsToScope(Value & attrs)
{
state.forceAttrs(attrs);
foreach (Bindings::iterator, 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)
{
staticEnv.vars[name] = displ;
env->values[displ++] = v;
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);
}
// 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:
str << "\"";
for (const char * i = v.string.s; *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 << "\"";
break;
case tPath:
str << v.path; // !!! escaping?
break;
case tNull:
str << "null";
break;
case tAttrs: {
seen.insert(&v);
bool isDrv = state.isDerivation(v);
if (isDrv) str << "(derivation ";
str << "{ ";
if (maxDepth > 0) {
typedef std::map<string, Value *> Sorted;
Sorted sorted;
foreach (Bindings::iterator, 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->list.length; ++j)
hidden.insert(state.forceStringNoCtx(*i->value->list.elems[j]));
}
}
foreach (Sorted::iterator, i, sorted) {
str << i->first << " = ";
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 << "; ";
}
} else
str << "... ";
str << "}";
if (isDrv) str << ")";
break;
}
case tList:
seen.insert(&v);
str << "[ ";
if (maxDepth > 0)
for (unsigned int n = 0; n < v.list.length; ++n) {
if (seen.find(v.list.elems[n]) != seen.end())
str << "«repeated»";
else
try {
printValue(str, *v.list.elems[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;
}
void run(Strings args)
{
NixRepl repl;
repl.mainLoop(args);
}