aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/nix/repl.cc719
1 files changed, 719 insertions, 0 deletions
diff --git a/src/nix/repl.cc b/src/nix/repl.cc
new file mode 100644
index 000000000..71790eb48
--- /dev/null
+++ b/src/nix/repl.cc
@@ -0,0 +1,719 @@
+#include <nix/config.h>
+
+#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"
+#include "globals.hh"
+
+using namespace std;
+using namespace nix;
+
+#define ESC_RED "\033[31m"
+#define ESC_GRE "\033[32m"
+#define ESC_YEL "\033[33m"
+#define ESC_BLU "\033[34;1m"
+#define ESC_MAG "\033[35m"
+#define ESC_CYA "\033[36m"
+#define ESC_END "\033[0m"
+
+string programId = "nix-repl";
+const string historyFile = string(getenv("HOME")) + "/.nix-repl-history";
+
+struct NixRepl
+{
+ string curDir;
+ EvalState state;
+
+ Strings loadedFiles;
+
+ const static int envSize = 32768;
+ StaticEnv staticEnv;
+ Env * env;
+ int displ;
+ StringSet varNames;
+
+ StringSet completions;
+ StringSet::iterator curCompletion;
+
+ NixRepl(const Strings & searchPath, nix::ref<Store> store);
+ void mainLoop(const Strings & files);
+ void completePrefix(string prefix);
+ bool getLine(string & input, const char * prompt);
+ Path getDerivationPath(Value & v);
+ bool processLine(string line);
+ void loadFile(const Path & path);
+ void initEnv();
+ 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);
+
+ reloadFiles();
+ if (!loadedFiles.empty()) std::cout << std::endl;
+
+ // Allow nix-repl specific settings in .inputrc
+ rl_readline_name = "nix-repl";
+ using_history();
+ read_history(historyFile.c_str());
+
+ string input;
+
+ while (true) {
+ // 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> " : " ";
+ if (!getLine(input, prompt)) {
+ 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;
+ }
+}
+
+
+/* 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 & input, const char * prompt)
+{
+ 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)) {
+ input.clear();
+ } else {
+ curRepl = this;
+ rl_completion_entry_function = completerThunk;
+
+ char * s = readline(prompt);
+ if (!s) return false;
+ input.append(s);
+ input.push_back('\n');
+ if (!removeWhitespace(s).empty()) {
+ add_history(s);
+ append_history(1, 0);
+ }
+ free(s);
+ }
+
+ _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.
+ }
+ }
+}
+
+
+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();
+}
+
+
+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;
+}
+
+
+bool NixRepl::processLine(string line)
+{
+ if (line == "") return true;
+
+ string command, arg;
+
+ if (line[0] == ':') {
+ size_t p = line.find_first_of(" \n\r\t");
+ command = string(line, 0, p);
+ if (p != string::npos) arg = removeWhitespace(string(line, p));
+ } else {
+ arg = line;
+ }
+
+ if (command == ":?" || command == ":help") {
+ 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"
+ << " :q Exit nix-repl\n"
+ << " :r Reload all files\n"
+ << " :s <expr> Build dependencies of derivation, then start nix-shell\n"
+ << " :t <expr> Describe result of evaluation\n"
+ << " :u <expr> Build derivation, then start nix-shell\n";
+ }
+
+ else if (command == ":a" || command == ":add") {
+ Value v;
+ evalString(arg, v);
+ addAttrsToScope(v);
+ }
+
+ else if (command == ":l" || command == ":load") {
+ state.resetFileCache();
+ loadFile(arg);
+ }
+
+ else if (command == ":r" || command == ":reload") {
+ state.resetFileCache();
+ reloadFiles();
+ }
+
+ else if (command == ":t") {
+ Value v;
+ evalString(arg, v);
+ std::cout << showType(v) << std::endl;
+
+ } 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") {
+ Value v;
+ 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. */
+ if (runProgram("nix-store", Strings{"-r", drvPath}) == 0) {
+ Derivation drv = readDerivation(drvPath);
+ 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;
+ }
+ } else if (command == ":i") {
+ runProgram("nix-env", Strings{"-i", drvPath});
+ } else {
+ runProgram("nix-shell", Strings{drvPath});
+ }
+ }
+
+ else if (command == ":p" || command == ":print") {
+ Value v;
+ evalString(arg, v);
+ printValue(std::cout, v, 1000000000) << std::endl;
+ }
+
+ else if (command == ":q" || command == ":quit")
+ return false;
+
+ else if (command != "")
+ throw Error(format("unknown command ‘%1%’") % command);
+
+ 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;
+ }
+ }
+
+ return true;
+}
+
+
+void NixRepl::loadFile(const Path & path)
+{
+ 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);
+}
+
+
+void NixRepl::initEnv()
+{
+ env = &state.allocEnv(envSize);
+ env->up = &state.baseEnv;
+ displ = 0;
+ staticEnv.vars.clear();
+
+ varNames.clear();
+ for (auto & i : state.staticBaseEnv.vars)
+ varNames.insert(i.first);
+}
+
+
+void NixRepl::reloadFiles()
+{
+ initEnv();
+
+ 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);
+ }
+}
+
+
+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)
+{
+ if (displ >= envSize)
+ throw Error("environment full; cannot add more variables");
+ 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);
+}
+
+
+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 << ESC_CYA << v.integer << ESC_END;
+ break;
+
+ case tBool:
+ str << ESC_CYA << (v.boolean ? "true" : "false") << ESC_END;
+ break;
+
+ case tString:
+ str << ESC_YEL;
+ printStringValue(str, v.string.s);
+ str << ESC_END;
+ break;
+
+ case tPath:
+ str << ESC_GRE << v.path << ESC_END; // !!! escaping?
+ break;
+
+ case tNull:
+ str << ESC_CYA "null" ESC_END;
+ break;
+
+ case tAttrs: {
+ seen.insert(&v);
+
+ bool isDrv = state.isDerivation(v);
+
+ if (isDrv) {
+ str << "«derivation ";
+ Bindings::iterator i = v.attrs->find(state.sDrvPath);
+ PathSet context;
+ Path drvPath = i != v.attrs->end() ? state.coerceToPath(*i->pos, *i->value, context) : "???";
+ 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 << ESC_RED "«error: " << e.msg() << "»" ESC_END;
+ }
+ str << "; ";
+ }
+
+ str << "}";
+ } else
+ 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 << ESC_RED "«error: " << e.msg() << "»" ESC_END;
+ }
+ str << " ";
+ }
+ else
+ str << "... ";
+ str << "]";
+ break;
+
+ case tLambda: {
+ std::ostringstream s;
+ s << v.lambda.fun->pos;
+ str << ESC_BLU "«lambda @ " << filterANSIEscapes(s.str()) << "»" ESC_END;
+ break;
+ }
+
+ case tPrimOp:
+ str << ESC_MAG "«primop»" ESC_END;
+ break;
+
+ case tPrimOpApp:
+ str << ESC_BLU "«primop-app»" ESC_END;
+ break;
+
+ default:
+ str << ESC_RED "«unknown»" ESC_END;
+ break;
+ }
+
+ return str;
+}
+
+
+int main(int argc, char * * argv)
+{
+ return handleExceptions(argv[0], [&]() {
+ initNix();
+ initGC();
+
+ 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);
+ }
+ 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);
+
+ write_history(historyFile.c_str());
+ });
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 14:40:03 +0000