2013-09-02 13:18:15 +00:00
|
|
|
#include <iostream>
|
|
|
|
#include <cstdlib>
|
2018-10-29 13:44:58 +00:00
|
|
|
#include <cstring>
|
|
|
|
#include <climits>
|
2013-09-02 13:18:15 +00:00
|
|
|
|
2013-09-06 11:01:02 +00:00
|
|
|
#include <setjmp.h>
|
|
|
|
|
2018-11-15 20:15:11 +00:00
|
|
|
#ifdef READLINE
|
|
|
|
#include <readline/history.h>
|
|
|
|
#include <readline/readline.h>
|
|
|
|
#else
|
2019-07-02 23:46:07 +00:00
|
|
|
// editline < 1.15.2 don't wrap their API for C++ usage
|
|
|
|
// (added in https://github.com/troglobit/editline/commit/91398ceb3427b730995357e9d120539fb9bb7461).
|
|
|
|
// This results in linker errors due to to name-mangling of editline C symbols.
|
|
|
|
// For compatibility with these versions, we wrap the API here
|
|
|
|
// (wrapping multiple times on newer versions is no problem).
|
|
|
|
extern "C" {
|
2018-10-29 13:44:58 +00:00
|
|
|
#include <editline.h>
|
2019-07-02 23:46:07 +00:00
|
|
|
}
|
2018-11-15 20:15:11 +00:00
|
|
|
#endif
|
2018-10-29 13:44:58 +00:00
|
|
|
|
2020-06-17 15:13:00 +00:00
|
|
|
#include "ansicolor.hh"
|
2013-09-02 13:18:15 +00:00
|
|
|
#include "shared.hh"
|
|
|
|
#include "eval.hh"
|
2013-09-02 15:53:58 +00:00
|
|
|
#include "eval-inline.hh"
|
2019-10-23 13:29:16 +00:00
|
|
|
#include "attr-path.hh"
|
2013-09-02 15:53:58 +00:00
|
|
|
#include "store-api.hh"
|
2017-10-24 10:45:11 +00:00
|
|
|
#include "common-eval-args.hh"
|
2013-09-06 12:58:53 +00:00
|
|
|
#include "get-drvs.hh"
|
|
|
|
#include "derivations.hh"
|
2013-09-06 19:00:36 +00:00
|
|
|
#include "affinity.hh"
|
2016-03-19 13:52:39 +00:00
|
|
|
#include "globals.hh"
|
2017-04-25 16:48:40 +00:00
|
|
|
#include "command.hh"
|
2017-05-10 16:34:18 +00:00
|
|
|
#include "finally.hh"
|
|
|
|
|
2020-03-19 12:50:01 +00:00
|
|
|
#define GC_INCLUDE_NEW
|
|
|
|
#include <gc/gc_cpp.h>
|
|
|
|
|
2017-04-25 16:48:40 +00:00
|
|
|
namespace nix {
|
2013-09-02 13:18:15 +00:00
|
|
|
|
2020-03-19 12:50:01 +00:00
|
|
|
struct NixRepl : gc
|
2013-09-02 15:53:58 +00:00
|
|
|
{
|
|
|
|
string curDir;
|
2020-03-19 12:52:28 +00:00
|
|
|
std::unique_ptr<EvalState> state;
|
2018-09-10 07:07:50 +00:00
|
|
|
Bindings * autoArgs;
|
2013-09-02 15:53:58 +00:00
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
Strings loadedFiles;
|
|
|
|
|
2013-09-09 15:06:14 +00:00
|
|
|
const static int envSize = 32768;
|
2013-09-02 15:53:58 +00:00
|
|
|
StaticEnv staticEnv;
|
|
|
|
Env * env;
|
|
|
|
int displ;
|
2013-09-06 17:51:59 +00:00
|
|
|
StringSet varNames;
|
|
|
|
|
2017-04-25 16:56:29 +00:00
|
|
|
const Path historyFile;
|
|
|
|
|
2016-02-28 22:41:16 +00:00
|
|
|
NixRepl(const Strings & searchPath, nix::ref<Store> store);
|
2017-04-25 16:48:40 +00:00
|
|
|
~NixRepl();
|
2017-10-24 10:45:11 +00:00
|
|
|
void mainLoop(const std::vector<std::string> & files);
|
2017-05-10 16:34:18 +00:00
|
|
|
StringSet completePrefix(string prefix);
|
|
|
|
bool getLine(string & input, const std::string &prompt);
|
2020-06-17 03:56:48 +00:00
|
|
|
StorePath getDerivationPath(Value & v);
|
2013-09-09 13:02:56 +00:00
|
|
|
bool processLine(string line);
|
2013-09-06 13:20:06 +00:00
|
|
|
void loadFile(const Path & path);
|
2013-09-09 15:06:14 +00:00
|
|
|
void initEnv();
|
2013-09-09 14:02:46 +00:00
|
|
|
void reloadFiles();
|
2013-09-02 16:18:27 +00:00
|
|
|
void addAttrsToScope(Value & attrs);
|
2013-09-09 11:56:53 +00:00
|
|
|
void addVarToScope(const Symbol & name, Value & v);
|
2013-09-02 15:53:58 +00:00
|
|
|
Expr * parseString(string s);
|
2013-09-02 16:00:48 +00:00
|
|
|
void evalString(string s, Value & v);
|
2013-09-09 09:14:43 +00:00
|
|
|
|
|
|
|
typedef set<Value *> ValuesSeen;
|
2013-09-06 22:35:54 +00:00
|
|
|
std::ostream & printValue(std::ostream & str, Value & v, unsigned int maxDepth);
|
2013-09-09 09:14:43 +00:00
|
|
|
std::ostream & printValue(std::ostream & str, Value & v, unsigned int maxDepth, ValuesSeen & seen);
|
2013-09-02 15:53:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2013-09-02 16:18:27 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-02-28 22:41:16 +00:00
|
|
|
NixRepl::NixRepl(const Strings & searchPath, nix::ref<Store> store)
|
2020-03-19 12:52:28 +00:00
|
|
|
: state(std::make_unique<EvalState>(searchPath, store))
|
|
|
|
, staticEnv(false, &state->staticBaseEnv)
|
2017-04-25 16:56:29 +00:00
|
|
|
, historyFile(getDataDir() + "/nix/repl-history")
|
2013-09-02 13:18:15 +00:00
|
|
|
{
|
2013-09-02 15:53:58 +00:00
|
|
|
curDir = absPath(".");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-04-25 16:48:40 +00:00
|
|
|
NixRepl::~NixRepl()
|
|
|
|
{
|
2018-10-29 13:44:58 +00:00
|
|
|
write_history(historyFile.c_str());
|
2017-05-10 16:34:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static NixRepl * curRepl; // ugly
|
|
|
|
|
2018-10-29 13:44:58 +00:00
|
|
|
static char * completionCallback(char * s, int *match) {
|
|
|
|
auto possible = curRepl->completePrefix(s);
|
|
|
|
if (possible.size() == 1) {
|
|
|
|
*match = 1;
|
|
|
|
auto *res = strdup(possible.begin()->c_str() + strlen(s));
|
|
|
|
if (!res) throw Error("allocation failure");
|
|
|
|
return res;
|
2018-06-26 18:06:46 +00:00
|
|
|
} else if (possible.size() > 1) {
|
|
|
|
auto checkAllHaveSameAt = [&](size_t pos) {
|
|
|
|
auto &first = *possible.begin();
|
|
|
|
for (auto &p : possible) {
|
|
|
|
if (p.size() <= pos || p[pos] != first[pos])
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
size_t start = strlen(s);
|
|
|
|
size_t len = 0;
|
|
|
|
while (checkAllHaveSameAt(start + len)) ++len;
|
|
|
|
if (len > 0) {
|
|
|
|
*match = 1;
|
|
|
|
auto *res = strdup(std::string(*possible.begin(), start, len).c_str());
|
|
|
|
if (!res) throw Error("allocation failure");
|
|
|
|
return res;
|
|
|
|
}
|
2018-10-29 13:44:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*match = 0;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int listPossibleCallback(char *s, char ***avp) {
|
|
|
|
auto possible = curRepl->completePrefix(s);
|
|
|
|
|
|
|
|
if (possible.size() > (INT_MAX / sizeof(char*)))
|
|
|
|
throw Error("too many completions");
|
|
|
|
|
|
|
|
int ac = 0;
|
|
|
|
char **vp = nullptr;
|
|
|
|
|
|
|
|
auto check = [&](auto *p) {
|
|
|
|
if (!p) {
|
|
|
|
if (vp) {
|
|
|
|
while (--ac >= 0)
|
|
|
|
free(vp[ac]);
|
|
|
|
free(vp);
|
|
|
|
}
|
|
|
|
throw Error("allocation failure");
|
|
|
|
}
|
|
|
|
return p;
|
|
|
|
};
|
|
|
|
|
|
|
|
vp = check((char **)malloc(possible.size() * sizeof(char*)));
|
|
|
|
|
|
|
|
for (auto & p : possible)
|
|
|
|
vp[ac++] = check(strdup(p.c_str()));
|
|
|
|
|
|
|
|
*avp = vp;
|
|
|
|
|
|
|
|
return ac;
|
2017-04-25 16:48:40 +00:00
|
|
|
}
|
|
|
|
|
2019-03-24 09:39:48 +00:00
|
|
|
namespace {
|
|
|
|
// Used to communicate to NixRepl::getLine whether a signal occurred in ::readline.
|
|
|
|
volatile sig_atomic_t g_signal_received = 0;
|
|
|
|
|
|
|
|
void sigintHandler(int signo) {
|
|
|
|
g_signal_received = signo;
|
|
|
|
}
|
|
|
|
}
|
2017-04-25 16:48:40 +00:00
|
|
|
|
2017-10-24 10:45:11 +00:00
|
|
|
void NixRepl::mainLoop(const std::vector<std::string> & files)
|
2013-09-02 15:53:58 +00:00
|
|
|
{
|
2016-03-19 13:52:39 +00:00
|
|
|
string error = ANSI_RED "error:" ANSI_NORMAL " ";
|
2017-04-25 16:48:40 +00:00
|
|
|
std::cout << "Welcome to Nix version " << nixVersion << ". Type :? for help." << std::endl << std::endl;
|
2013-09-06 13:20:06 +00:00
|
|
|
|
2015-09-07 11:05:58 +00:00
|
|
|
for (auto & i : files)
|
|
|
|
loadedFiles.push_back(i);
|
2013-09-09 14:02:46 +00:00
|
|
|
|
2013-09-09 15:06:14 +00:00
|
|
|
reloadFiles();
|
|
|
|
if (!loadedFiles.empty()) std::cout << std::endl;
|
2013-09-02 13:18:15 +00:00
|
|
|
|
2018-10-29 13:44:58 +00:00
|
|
|
// Allow nix-repl specific settings in .inputrc
|
|
|
|
rl_readline_name = "nix-repl";
|
2017-04-25 16:56:29 +00:00
|
|
|
createDirs(dirOf(historyFile));
|
2018-11-15 20:15:11 +00:00
|
|
|
#ifndef READLINE
|
2018-10-29 13:44:58 +00:00
|
|
|
el_hist_size = 1000;
|
2018-11-15 20:15:11 +00:00
|
|
|
#endif
|
2018-10-29 13:44:58 +00:00
|
|
|
read_history(historyFile.c_str());
|
2017-05-10 16:34:18 +00:00
|
|
|
curRepl = this;
|
2018-11-15 20:15:11 +00:00
|
|
|
#ifndef READLINE
|
2018-10-29 13:44:58 +00:00
|
|
|
rl_set_complete_func(completionCallback);
|
|
|
|
rl_set_list_possib_func(listPossibleCallback);
|
2018-11-15 20:15:11 +00:00
|
|
|
#endif
|
2017-05-10 16:34:18 +00:00
|
|
|
|
|
|
|
std::string input;
|
2016-02-18 12:27:39 +00:00
|
|
|
|
2013-09-02 13:18:15 +00:00
|
|
|
while (true) {
|
2016-02-18 13:04:55 +00:00
|
|
|
// When continuing input from previous lines, don't print a prompt, just align to the same
|
2016-02-18 12:27:39 +00:00
|
|
|
// number of chars as the prompt.
|
2017-05-10 16:34:18 +00:00
|
|
|
if (!getLine(input, input.empty() ? "nix-repl> " : " "))
|
2013-09-09 13:02:56 +00:00
|
|
|
break;
|
2013-09-02 13:18:15 +00:00
|
|
|
|
|
|
|
try {
|
2016-02-24 00:30:21 +00:00
|
|
|
if (!removeWhitespace(input).empty() && !processLine(input)) return;
|
2016-02-18 12:27:39 +00:00
|
|
|
} 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 {
|
2020-06-24 19:14:49 +00:00
|
|
|
printMsg(lvlError, e.msg());
|
2016-02-18 12:27:39 +00:00
|
|
|
}
|
2013-09-02 13:18:15 +00:00
|
|
|
} catch (Error & e) {
|
2020-06-24 19:14:49 +00:00
|
|
|
printMsg(lvlError, e.msg());
|
2013-09-06 11:20:35 +00:00
|
|
|
} catch (Interrupted & e) {
|
2020-06-24 19:14:49 +00:00
|
|
|
printMsg(lvlError, e.msg());
|
2013-09-02 13:18:15 +00:00
|
|
|
}
|
|
|
|
|
2017-05-10 16:34:18 +00:00
|
|
|
// We handled the current input fully, so we should clear it
|
|
|
|
// and read brand new input.
|
2016-02-18 12:27:39 +00:00
|
|
|
input.clear();
|
2013-09-02 13:18:15 +00:00
|
|
|
std::cout << std::endl;
|
|
|
|
}
|
|
|
|
}
|
2013-09-02 15:53:58 +00:00
|
|
|
|
|
|
|
|
2017-05-10 16:34:18 +00:00
|
|
|
bool NixRepl::getLine(string & input, const std::string &prompt)
|
2013-09-06 17:51:59 +00:00
|
|
|
{
|
2019-03-24 09:39:48 +00:00
|
|
|
struct sigaction act, old;
|
|
|
|
sigset_t savedSignalMask, set;
|
|
|
|
|
|
|
|
auto setupSignals = [&]() {
|
|
|
|
act.sa_handler = sigintHandler;
|
|
|
|
sigfillset(&act.sa_mask);
|
|
|
|
act.sa_flags = 0;
|
|
|
|
if (sigaction(SIGINT, &act, &old))
|
|
|
|
throw SysError("installing handler for SIGINT");
|
|
|
|
|
|
|
|
sigemptyset(&set);
|
|
|
|
sigaddset(&set, SIGINT);
|
|
|
|
if (sigprocmask(SIG_UNBLOCK, &set, &savedSignalMask))
|
|
|
|
throw SysError("unblocking SIGINT");
|
|
|
|
};
|
|
|
|
auto restoreSignals = [&]() {
|
|
|
|
if (sigprocmask(SIG_SETMASK, &savedSignalMask, nullptr))
|
|
|
|
throw SysError("restoring signals");
|
|
|
|
|
|
|
|
if (sigaction(SIGINT, &old, 0))
|
|
|
|
throw SysError("restoring handler for SIGINT");
|
|
|
|
};
|
|
|
|
|
|
|
|
setupSignals();
|
2018-10-29 13:44:58 +00:00
|
|
|
char * s = readline(prompt.c_str());
|
2017-11-28 00:30:05 +00:00
|
|
|
Finally doFree([&]() { free(s); });
|
2019-03-24 09:39:48 +00:00
|
|
|
restoreSignals();
|
|
|
|
|
|
|
|
if (g_signal_received) {
|
|
|
|
g_signal_received = 0;
|
|
|
|
input.clear();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-10-29 13:44:58 +00:00
|
|
|
if (!s)
|
|
|
|
return false;
|
2017-05-10 16:34:18 +00:00
|
|
|
input += s;
|
2018-04-11 09:42:17 +00:00
|
|
|
input += '\n';
|
2017-05-10 16:34:18 +00:00
|
|
|
return true;
|
2013-09-06 17:51:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-05-10 16:34:18 +00:00
|
|
|
StringSet NixRepl::completePrefix(string prefix)
|
2013-09-06 17:51:59 +00:00
|
|
|
{
|
2017-05-10 16:34:18 +00:00
|
|
|
StringSet completions;
|
2017-04-25 17:19:15 +00:00
|
|
|
|
2017-05-10 16:34:18 +00:00
|
|
|
size_t start = prefix.find_last_of(" \n\r\t(){}[]");
|
|
|
|
std::string prev, cur;
|
|
|
|
if (start == std::string::npos) {
|
|
|
|
prev = "";
|
|
|
|
cur = prefix;
|
2016-02-18 12:50:52 +00:00
|
|
|
} else {
|
2017-05-10 16:34:18 +00:00
|
|
|
prev = std::string(prefix, 0, start + 1);
|
|
|
|
cur = std::string(prefix, start + 1);
|
2013-09-06 17:51:59 +00:00
|
|
|
}
|
|
|
|
|
2017-05-10 16:34:18 +00:00
|
|
|
size_t slash, dot;
|
2013-09-09 10:00:33 +00:00
|
|
|
|
2017-05-10 16:34:18 +00:00
|
|
|
if ((slash = cur.rfind('/')) != string::npos) {
|
|
|
|
try {
|
|
|
|
auto dir = std::string(cur, 0, slash);
|
|
|
|
auto prefix2 = std::string(cur, slash + 1);
|
|
|
|
for (auto & entry : readDirectory(dir == "" ? "/" : dir)) {
|
|
|
|
if (entry.name[0] != '.' && hasPrefix(entry.name, prefix2))
|
|
|
|
completions.insert(prev + dir + "/" + entry.name);
|
|
|
|
}
|
|
|
|
} catch (Error &) {
|
|
|
|
}
|
|
|
|
} else if ((dot = cur.rfind('.')) == string::npos) {
|
2013-09-09 10:00:33 +00:00
|
|
|
/* This is a variable name; look it up in the current scope. */
|
2017-05-10 16:34:18 +00:00
|
|
|
StringSet::iterator i = varNames.lower_bound(cur);
|
2013-09-09 10:00:33 +00:00
|
|
|
while (i != varNames.end()) {
|
2017-05-10 16:34:18 +00:00
|
|
|
if (string(*i, 0, cur.size()) != cur) break;
|
|
|
|
completions.insert(prev + *i);
|
2013-09-09 10:00:33 +00:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
try {
|
|
|
|
/* This is an expression that should evaluate to an
|
|
|
|
attribute set. Evaluate it to get the names of the
|
|
|
|
attributes. */
|
2017-05-10 16:34:18 +00:00
|
|
|
string expr(cur, 0, dot);
|
|
|
|
string cur2 = string(cur, dot + 1);
|
2013-09-09 10:00:33 +00:00
|
|
|
|
|
|
|
Expr * e = parseString(expr);
|
|
|
|
Value v;
|
2020-03-19 12:52:28 +00:00
|
|
|
e->eval(*state, *env, v);
|
|
|
|
state->forceAttrs(v);
|
2013-09-09 10:00:33 +00:00
|
|
|
|
2015-09-07 11:05:58 +00:00
|
|
|
for (auto & i : *v.attrs) {
|
|
|
|
string name = i.name;
|
2017-05-10 16:34:18 +00:00
|
|
|
if (string(name, 0, cur2.size()) != cur2) continue;
|
|
|
|
completions.insert(prev + expr + "." + name);
|
2013-09-09 10:00:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} catch (ParseError & e) {
|
|
|
|
// Quietly ignore parse errors.
|
2014-04-11 10:51:15 +00:00
|
|
|
} catch (EvalError & e) {
|
2013-09-09 10:00:33 +00:00
|
|
|
// Quietly ignore evaluation errors.
|
2014-04-11 10:51:15 +00:00
|
|
|
} catch (UndefinedVarError & e) {
|
|
|
|
// Quietly ignore undefined variable errors.
|
2013-09-09 10:00:33 +00:00
|
|
|
}
|
2013-09-06 17:51:59 +00:00
|
|
|
}
|
2017-05-10 16:34:18 +00:00
|
|
|
|
|
|
|
return completions;
|
2013-09-06 17:51:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-06 19:00:36 +00:00
|
|
|
static int runProgram(const string & program, const Strings & args)
|
|
|
|
{
|
2017-04-25 17:10:47 +00:00
|
|
|
Strings args2(args);
|
|
|
|
args2.push_front(program);
|
2013-09-06 19:00:36 +00:00
|
|
|
|
|
|
|
Pid pid;
|
|
|
|
pid = fork();
|
|
|
|
if (pid == -1) throw SysError("forking");
|
|
|
|
if (pid == 0) {
|
|
|
|
restoreAffinity();
|
2017-04-25 17:10:47 +00:00
|
|
|
execvp(program.c_str(), stringsToCharPtrs(args2).data());
|
2013-09-06 19:00:36 +00:00
|
|
|
_exit(1);
|
|
|
|
}
|
|
|
|
|
2017-04-25 14:55:03 +00:00
|
|
|
return pid.wait();
|
2013-09-06 19:00:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-09 11:56:53 +00:00
|
|
|
bool isVarName(const string & s)
|
|
|
|
{
|
2016-02-14 07:50:47 +00:00
|
|
|
if (s.size() == 0) return false;
|
|
|
|
char c = s[0];
|
|
|
|
if ((c >= '0' && c <= '9') || c == '-' || c == '\'') return false;
|
2015-09-07 11:05:58 +00:00
|
|
|
for (auto & i : s)
|
|
|
|
if (!((i >= 'a' && i <= 'z') ||
|
|
|
|
(i >= 'A' && i <= 'Z') ||
|
|
|
|
(i >= '0' && i <= '9') ||
|
2016-02-14 07:16:30 +00:00
|
|
|
i == '_' || i == '-' || i == '\''))
|
2013-09-09 11:56:53 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-17 03:56:48 +00:00
|
|
|
StorePath NixRepl::getDerivationPath(Value & v) {
|
2020-03-19 12:52:28 +00:00
|
|
|
auto drvInfo = getDerivation(*state, v, false);
|
2017-07-20 11:32:01 +00:00
|
|
|
if (!drvInfo)
|
2016-02-18 02:31:30 +00:00
|
|
|
throw Error("expression does not evaluate to a derivation, so I can't build it");
|
2020-06-17 03:56:48 +00:00
|
|
|
Path drvPathRaw = drvInfo->queryDrvPath();
|
|
|
|
if (drvPathRaw == "")
|
|
|
|
throw Error("expression did not evaluate to a valid derivation (no drv path)");
|
|
|
|
StorePath drvPath = state->store->parseStorePath(drvPathRaw);
|
|
|
|
if (!state->store->isValidPath(drvPath))
|
|
|
|
throw Error("expression did not evaluate to a valid derivation (invalid drv path)");
|
2016-02-18 02:31:30 +00:00
|
|
|
return drvPath;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-09 13:02:56 +00:00
|
|
|
bool NixRepl::processLine(string line)
|
2013-09-02 15:53:58 +00:00
|
|
|
{
|
2013-09-09 13:02:56 +00:00
|
|
|
if (line == "") return true;
|
|
|
|
|
|
|
|
string command, arg;
|
2013-09-06 11:01:02 +00:00
|
|
|
|
2013-09-09 13:02:56 +00:00
|
|
|
if (line[0] == ':') {
|
2016-02-18 12:59:51 +00:00
|
|
|
size_t p = line.find_first_of(" \n\r\t");
|
2013-09-09 13:02:56 +00:00
|
|
|
command = string(line, 0, p);
|
|
|
|
if (p != string::npos) arg = removeWhitespace(string(line, p));
|
|
|
|
} else {
|
|
|
|
arg = line;
|
|
|
|
}
|
2013-09-06 13:05:18 +00:00
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
if (command == ":?" || command == ":help") {
|
2017-04-25 16:58:02 +00:00
|
|
|
std::cout
|
|
|
|
<< "The following commands are available:\n"
|
2013-09-09 11:22:33 +00:00
|
|
|
<< "\n"
|
2013-09-09 11:56:53 +00:00
|
|
|
<< " <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"
|
2019-10-23 13:29:16 +00:00
|
|
|
<< " :e <expr> Open the derivation in $EDITOR\n"
|
2016-02-16 06:24:50 +00:00
|
|
|
<< " :i <expr> Build derivation, then install result into current profile\n"
|
2013-09-09 11:56:53 +00:00
|
|
|
<< " :l <path> Load Nix expression and add it to scope\n"
|
|
|
|
<< " :p <expr> Evaluate and print expression recursively\n"
|
2013-09-09 13:02:56 +00:00
|
|
|
<< " :q Exit nix-repl\n"
|
2013-09-09 14:02:46 +00:00
|
|
|
<< " :r Reload all files\n"
|
2013-09-09 11:56:53 +00:00
|
|
|
<< " :s <expr> Build dependencies of derivation, then start nix-shell\n"
|
2016-02-18 02:31:30 +00:00
|
|
|
<< " :t <expr> Describe result of evaluation\n"
|
2016-02-19 10:00:36 +00:00
|
|
|
<< " :u <expr> Build derivation, then start nix-shell\n";
|
2013-09-09 11:22:33 +00:00
|
|
|
}
|
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
else if (command == ":a" || command == ":add") {
|
2013-09-02 15:53:58 +00:00
|
|
|
Value v;
|
2013-09-09 13:02:56 +00:00
|
|
|
evalString(arg, v);
|
2013-09-02 16:18:27 +00:00
|
|
|
addAttrsToScope(v);
|
|
|
|
}
|
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
else if (command == ":l" || command == ":load") {
|
2020-03-19 12:52:28 +00:00
|
|
|
state->resetFileCache();
|
2013-09-09 13:02:56 +00:00
|
|
|
loadFile(arg);
|
2013-09-02 15:53:58 +00:00
|
|
|
}
|
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
else if (command == ":r" || command == ":reload") {
|
2020-03-19 12:52:28 +00:00
|
|
|
state->resetFileCache();
|
2013-09-09 14:02:46 +00:00
|
|
|
reloadFiles();
|
|
|
|
}
|
|
|
|
|
2019-10-23 13:29:16 +00:00
|
|
|
else if (command == ":e" || command == ":edit") {
|
|
|
|
Value v;
|
|
|
|
evalString(arg, v);
|
|
|
|
|
2019-10-28 20:36:34 +00:00
|
|
|
Pos pos;
|
2019-10-23 13:29:16 +00:00
|
|
|
|
|
|
|
if (v.type == tPath || v.type == tString) {
|
|
|
|
PathSet context;
|
2020-03-19 12:52:28 +00:00
|
|
|
auto filename = state->coerceToString(noPos, v, context);
|
|
|
|
pos.file = state->symbols.create(filename);
|
2019-10-28 20:37:22 +00:00
|
|
|
} else if (v.type == tLambda) {
|
|
|
|
pos = v.lambda.fun->pos;
|
2019-10-23 13:29:16 +00:00
|
|
|
} else {
|
|
|
|
// assume it's a derivation
|
2020-03-19 12:52:28 +00:00
|
|
|
pos = findDerivationFilename(*state, v, arg);
|
2019-10-23 13:29:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Open in EDITOR
|
2019-10-28 20:36:34 +00:00
|
|
|
auto args = editorFor(pos);
|
2019-10-23 14:48:28 +00:00
|
|
|
auto editor = args.front();
|
2019-10-23 13:29:16 +00:00
|
|
|
args.pop_front();
|
|
|
|
runProgram(editor, args);
|
|
|
|
|
|
|
|
// Reload right after exiting the editor
|
2020-03-19 12:52:28 +00:00
|
|
|
state->resetFileCache();
|
2019-10-23 13:29:16 +00:00
|
|
|
reloadFiles();
|
|
|
|
}
|
|
|
|
|
2013-09-06 13:05:18 +00:00
|
|
|
else if (command == ":t") {
|
2013-09-02 16:00:48 +00:00
|
|
|
Value v;
|
2013-09-09 13:02:56 +00:00
|
|
|
evalString(arg, v);
|
2013-09-02 16:00:48 +00:00
|
|
|
std::cout << showType(v) << std::endl;
|
2016-02-18 02:31:30 +00:00
|
|
|
|
2016-02-19 10:00:36 +00:00
|
|
|
} else if (command == ":u") {
|
2016-02-18 02:31:30 +00:00
|
|
|
Value v, f, result;
|
|
|
|
evalString(arg, v);
|
|
|
|
evalString("drv: (import <nixpkgs> {}).runCommand \"shell\" { buildInputs = [ drv ]; } \"\"", f);
|
2020-03-19 12:52:28 +00:00
|
|
|
state->callFunction(f, v, result, Pos());
|
2016-02-18 02:31:30 +00:00
|
|
|
|
2020-06-17 03:56:48 +00:00
|
|
|
StorePath drvPath = getDerivationPath(result);
|
|
|
|
runProgram(settings.nixBinDir + "/nix-shell", Strings{state->store->printStorePath(drvPath)});
|
2013-09-02 16:00:48 +00:00
|
|
|
}
|
|
|
|
|
2016-02-16 06:24:50 +00:00
|
|
|
else if (command == ":b" || command == ":i" || command == ":s") {
|
2013-09-06 12:58:53 +00:00
|
|
|
Value v;
|
2013-09-09 13:02:56 +00:00
|
|
|
evalString(arg, v);
|
2020-06-17 03:56:48 +00:00
|
|
|
StorePath drvPath = getDerivationPath(v);
|
|
|
|
Path drvPathRaw = state->store->printStorePath(drvPath);
|
2013-09-06 13:05:18 +00:00
|
|
|
|
|
|
|
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. */
|
2020-06-17 03:56:48 +00:00
|
|
|
if (runProgram(settings.nixBinDir + "/nix", Strings{"build", "--no-link", drvPathRaw}) == 0) {
|
|
|
|
auto drv = state->store->readDerivation(drvPath);
|
2013-09-09 13:02:56 +00:00
|
|
|
std::cout << std::endl << "this derivation produced the following outputs:" << std::endl;
|
2015-09-07 11:05:58 +00:00
|
|
|
for (auto & i : drv.outputs)
|
2020-07-08 23:11:39 +00:00
|
|
|
std::cout << fmt(" %s -> %s\n", i.first, state->store->printStorePath(i.second.path(*state->store, drv.name)));
|
2013-09-09 13:02:56 +00:00
|
|
|
}
|
2016-02-16 06:24:50 +00:00
|
|
|
} else if (command == ":i") {
|
2020-06-17 03:56:48 +00:00
|
|
|
runProgram(settings.nixBinDir + "/nix-env", Strings{"-i", drvPathRaw});
|
2016-02-16 06:24:50 +00:00
|
|
|
} else {
|
2020-06-17 03:56:48 +00:00
|
|
|
runProgram(settings.nixBinDir + "/nix-shell", Strings{drvPathRaw});
|
2016-02-16 06:24:50 +00:00
|
|
|
}
|
2013-09-02 15:53:58 +00:00
|
|
|
}
|
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
else if (command == ":p" || command == ":print") {
|
2013-09-06 22:35:54 +00:00
|
|
|
Value v;
|
2013-09-09 13:02:56 +00:00
|
|
|
evalString(arg, v);
|
2013-09-06 22:35:54 +00:00
|
|
|
printValue(std::cout, v, 1000000000) << std::endl;
|
|
|
|
}
|
|
|
|
|
2013-09-09 13:02:56 +00:00
|
|
|
else if (command == ":q" || command == ":quit")
|
|
|
|
return false;
|
|
|
|
|
|
|
|
else if (command != "")
|
2020-04-21 23:07:07 +00:00
|
|
|
throw Error("unknown command '%1%'", command);
|
2013-09-06 12:58:53 +00:00
|
|
|
|
2013-09-02 15:53:58 +00:00
|
|
|
else {
|
2013-09-09 11:56:53 +00:00
|
|
|
size_t p = line.find('=');
|
|
|
|
string name;
|
|
|
|
if (p != string::npos &&
|
2014-06-16 14:05:09 +00:00
|
|
|
p < line.size() &&
|
|
|
|
line[p + 1] != '=' &&
|
2013-09-09 11:56:53 +00:00
|
|
|
isVarName(name = removeWhitespace(string(line, 0, p))))
|
|
|
|
{
|
|
|
|
Expr * e = parseString(string(line, p + 1));
|
2020-03-19 12:52:28 +00:00
|
|
|
Value & v(*state->allocValue());
|
2013-09-09 11:56:53 +00:00
|
|
|
v.type = tThunk;
|
|
|
|
v.thunk.env = env;
|
|
|
|
v.thunk.expr = e;
|
2020-03-19 12:52:28 +00:00
|
|
|
addVarToScope(state->symbols.create(name), v);
|
2013-09-09 11:56:53 +00:00
|
|
|
} else {
|
|
|
|
Value v;
|
|
|
|
evalString(line, v);
|
|
|
|
printValue(std::cout, v, 1) << std::endl;
|
|
|
|
}
|
2013-09-02 15:53:58 +00:00
|
|
|
}
|
2013-09-09 13:02:56 +00:00
|
|
|
|
|
|
|
return true;
|
2013-09-02 15:53:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-06 13:20:06 +00:00
|
|
|
void NixRepl::loadFile(const Path & path)
|
|
|
|
{
|
2013-09-09 14:02:46 +00:00
|
|
|
loadedFiles.remove(path);
|
|
|
|
loadedFiles.push_back(path);
|
2013-09-06 13:20:06 +00:00
|
|
|
Value v, v2;
|
2020-03-19 12:52:28 +00:00
|
|
|
state->evalFile(lookupFileArg(*state, path), v);
|
|
|
|
state->autoCallFunction(*autoArgs, v, v2);
|
2013-09-06 13:20:06 +00:00
|
|
|
addAttrsToScope(v2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-09 15:06:14 +00:00
|
|
|
void NixRepl::initEnv()
|
|
|
|
{
|
2020-03-19 12:52:28 +00:00
|
|
|
env = &state->allocEnv(envSize);
|
|
|
|
env->up = &state->baseEnv;
|
2013-09-09 15:06:14 +00:00
|
|
|
displ = 0;
|
|
|
|
staticEnv.vars.clear();
|
2013-09-09 15:22:42 +00:00
|
|
|
|
|
|
|
varNames.clear();
|
2020-03-19 12:52:28 +00:00
|
|
|
for (auto & i : state->staticBaseEnv.vars)
|
2015-09-07 11:05:58 +00:00
|
|
|
varNames.insert(i.first);
|
2013-09-09 15:06:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
void NixRepl::reloadFiles()
|
|
|
|
{
|
2013-09-09 15:06:14 +00:00
|
|
|
initEnv();
|
|
|
|
|
2013-09-09 14:02:46 +00:00
|
|
|
Strings old = loadedFiles;
|
|
|
|
loadedFiles.clear();
|
|
|
|
|
2015-09-07 11:05:58 +00:00
|
|
|
bool first = true;
|
|
|
|
for (auto & i : old) {
|
|
|
|
if (!first) std::cout << std::endl;
|
|
|
|
first = false;
|
2017-07-30 11:27:57 +00:00
|
|
|
std::cout << format("Loading '%1%'...") % i << std::endl;
|
2015-09-07 11:05:58 +00:00
|
|
|
loadFile(i);
|
2013-09-09 14:02:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-02 16:18:27 +00:00
|
|
|
void NixRepl::addAttrsToScope(Value & attrs)
|
|
|
|
{
|
2020-03-19 12:52:28 +00:00
|
|
|
state->forceAttrs(attrs);
|
2015-09-07 11:05:58 +00:00
|
|
|
for (auto & i : *attrs.attrs)
|
|
|
|
addVarToScope(i.name, *i.value);
|
2013-09-06 13:20:06 +00:00
|
|
|
std::cout << format("Added %1% variables.") % attrs.attrs->size() << std::endl;
|
2013-09-02 16:18:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-09 11:56:53 +00:00
|
|
|
void NixRepl::addVarToScope(const Symbol & name, Value & v)
|
2013-09-02 15:53:58 +00:00
|
|
|
{
|
2013-09-09 15:06:14 +00:00
|
|
|
if (displ >= envSize)
|
|
|
|
throw Error("environment full; cannot add more variables");
|
2013-09-02 15:53:58 +00:00
|
|
|
staticEnv.vars[name] = displ;
|
2013-09-09 11:56:53 +00:00
|
|
|
env->values[displ++] = &v;
|
2013-09-06 17:51:59 +00:00
|
|
|
varNames.insert((string) name);
|
2013-09-02 15:53:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Expr * NixRepl::parseString(string s)
|
|
|
|
{
|
2020-03-19 12:52:28 +00:00
|
|
|
Expr * e = state->parseExprFromString(s, curDir, staticEnv);
|
2013-09-02 15:53:58 +00:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-02 16:00:48 +00:00
|
|
|
void NixRepl::evalString(string s, Value & v)
|
|
|
|
{
|
|
|
|
Expr * e = parseString(s);
|
2020-03-19 12:52:28 +00:00
|
|
|
e->eval(*state, *env, v);
|
|
|
|
state->forceValue(v);
|
2013-09-02 16:00:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-09 09:14:43 +00:00
|
|
|
std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int maxDepth)
|
|
|
|
{
|
|
|
|
ValuesSeen seen;
|
|
|
|
return printValue(str, v, maxDepth, seen);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-02-20 07:10:06 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-06 22:35:54 +00:00
|
|
|
// FIXME: lot of cut&paste from Nix's eval.cc.
|
2013-09-09 09:14:43 +00:00
|
|
|
std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int maxDepth, ValuesSeen & seen)
|
2013-09-06 22:35:54 +00:00
|
|
|
{
|
|
|
|
str.flush();
|
|
|
|
checkInterrupt();
|
|
|
|
|
2020-03-19 12:52:28 +00:00
|
|
|
state->forceValue(v);
|
2013-09-06 22:35:54 +00:00
|
|
|
|
|
|
|
switch (v.type) {
|
|
|
|
|
|
|
|
case tInt:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_CYAN << v.integer << ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case tBool:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_CYAN << (v.boolean ? "true" : "false") << ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case tString:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_YELLOW;
|
2016-02-20 07:10:06 +00:00
|
|
|
printStringValue(str, v.string.s);
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case tPath:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_GREEN << v.path << ANSI_NORMAL; // !!! escaping?
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case tNull:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_CYAN "null" ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case tAttrs: {
|
2013-09-09 09:14:43 +00:00
|
|
|
seen.insert(&v);
|
|
|
|
|
2020-03-19 12:52:28 +00:00
|
|
|
bool isDrv = state->isDerivation(v);
|
2013-09-06 22:35:54 +00:00
|
|
|
|
2014-01-28 09:40:02 +00:00
|
|
|
if (isDrv) {
|
|
|
|
str << "«derivation ";
|
2020-03-19 12:52:28 +00:00
|
|
|
Bindings::iterator i = v.attrs->find(state->sDrvPath);
|
2014-01-28 09:40:02 +00:00
|
|
|
PathSet context;
|
2020-03-19 12:52:28 +00:00
|
|
|
Path drvPath = i != v.attrs->end() ? state->coerceToPath(*i->pos, *i->value, context) : "???";
|
2014-01-28 09:40:02 +00:00
|
|
|
str << drvPath << "»";
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (maxDepth > 0) {
|
|
|
|
str << "{ ";
|
|
|
|
|
2013-09-06 22:35:54 +00:00
|
|
|
typedef std::map<string, Value *> Sorted;
|
|
|
|
Sorted sorted;
|
2015-09-07 11:05:58 +00:00
|
|
|
for (auto & i : *v.attrs)
|
|
|
|
sorted[i.name] = i.value;
|
2013-09-06 22:35:54 +00:00
|
|
|
|
2015-09-07 11:05:58 +00:00
|
|
|
for (auto & i : sorted) {
|
2016-02-20 07:10:06 +00:00
|
|
|
if (isVarName(i.first))
|
|
|
|
str << i.first;
|
|
|
|
else
|
|
|
|
printStringValue(str, i.first.c_str());
|
|
|
|
str << " = ";
|
2018-12-25 19:35:46 +00:00
|
|
|
if (seen.find(i.second) != seen.end())
|
2013-09-09 09:34:54 +00:00
|
|
|
str << "«repeated»";
|
2013-09-06 22:35:54 +00:00
|
|
|
else
|
2013-09-09 09:34:54 +00:00
|
|
|
try {
|
2015-09-07 11:05:58 +00:00
|
|
|
printValue(str, *i.second, maxDepth - 1, seen);
|
2013-09-09 09:34:54 +00:00
|
|
|
} catch (AssertionError & e) {
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_RED "«error: " << e.msg() << "»" ANSI_NORMAL;
|
2013-09-09 09:34:54 +00:00
|
|
|
}
|
|
|
|
str << "; ";
|
|
|
|
}
|
2013-09-06 22:35:54 +00:00
|
|
|
|
2014-01-28 09:40:02 +00:00
|
|
|
str << "}";
|
2013-09-06 22:35:54 +00:00
|
|
|
} else
|
2014-01-28 09:40:02 +00:00
|
|
|
str << "{ ... }";
|
2013-09-06 22:35:54 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-09-07 11:05:58 +00:00
|
|
|
case tList1:
|
|
|
|
case tList2:
|
|
|
|
case tListN:
|
2013-09-09 09:14:43 +00:00
|
|
|
seen.insert(&v);
|
|
|
|
|
2013-09-06 22:35:54 +00:00
|
|
|
str << "[ ";
|
|
|
|
if (maxDepth > 0)
|
2015-09-07 11:05:58 +00:00
|
|
|
for (unsigned int n = 0; n < v.listSize(); ++n) {
|
|
|
|
if (seen.find(v.listElems()[n]) != seen.end())
|
2013-09-09 09:34:54 +00:00
|
|
|
str << "«repeated»";
|
2013-09-09 09:14:43 +00:00
|
|
|
else
|
2013-09-09 09:34:54 +00:00
|
|
|
try {
|
2015-09-07 11:05:58 +00:00
|
|
|
printValue(str, *v.listElems()[n], maxDepth - 1, seen);
|
2013-09-09 09:34:54 +00:00
|
|
|
} catch (AssertionError & e) {
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_RED "«error: " << e.msg() << "»" ANSI_NORMAL;
|
2013-09-09 09:34:54 +00:00
|
|
|
}
|
|
|
|
str << " ";
|
2013-09-09 09:14:43 +00:00
|
|
|
}
|
2013-09-06 22:35:54 +00:00
|
|
|
else
|
|
|
|
str << "... ";
|
|
|
|
str << "]";
|
|
|
|
break;
|
|
|
|
|
2016-07-21 09:21:59 +00:00
|
|
|
case tLambda: {
|
|
|
|
std::ostringstream s;
|
|
|
|
s << v.lambda.fun->pos;
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_BLUE "«lambda @ " << filterANSIEscapes(s.str()) << "»" ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
2016-07-21 09:21:59 +00:00
|
|
|
}
|
2013-09-06 22:35:54 +00:00
|
|
|
|
|
|
|
case tPrimOp:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_MAGENTA "«primop»" ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case tPrimOpApp:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_BLUE "«primop-app»" ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
|
2017-07-31 13:15:49 +00:00
|
|
|
case tFloat:
|
|
|
|
str << v.fpoint;
|
|
|
|
break;
|
|
|
|
|
2013-09-06 22:35:54 +00:00
|
|
|
default:
|
2020-06-17 15:13:00 +00:00
|
|
|
str << ANSI_RED "«unknown»" ANSI_NORMAL;
|
2013-09-06 22:35:54 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2017-10-24 10:45:11 +00:00
|
|
|
struct CmdRepl : StoreCommand, MixEvalArgs
|
2013-09-02 15:53:58 +00:00
|
|
|
{
|
2017-10-24 10:45:11 +00:00
|
|
|
std::vector<std::string> files;
|
2017-04-25 16:48:40 +00:00
|
|
|
|
|
|
|
CmdRepl()
|
|
|
|
{
|
2020-05-11 13:46:18 +00:00
|
|
|
expectArgs({
|
|
|
|
.label = "files",
|
|
|
|
.handler = {&files},
|
|
|
|
.completer = completePath
|
|
|
|
});
|
2017-04-25 16:48:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string description() override
|
|
|
|
{
|
|
|
|
return "start an interactive environment for evaluating Nix expressions";
|
|
|
|
}
|
|
|
|
|
2020-05-01 21:32:01 +00:00
|
|
|
Examples examples() override
|
|
|
|
{
|
|
|
|
return {
|
|
|
|
Example{
|
|
|
|
"Display all special commands within the REPL:",
|
|
|
|
"nix repl\n nix-repl> :?"
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2017-04-25 16:48:40 +00:00
|
|
|
void run(ref<Store> store) override
|
|
|
|
{
|
2019-09-02 21:04:27 +00:00
|
|
|
evalSettings.pureEval = false;
|
2018-06-12 15:26:36 +00:00
|
|
|
auto repl = std::make_unique<NixRepl>(searchPath, openStore());
|
2020-03-19 12:52:28 +00:00
|
|
|
repl->autoArgs = getAutoArgs(*repl->state);
|
2018-06-12 15:26:36 +00:00
|
|
|
repl->mainLoop(files);
|
2017-04-25 16:48:40 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-06-18 14:01:35 +00:00
|
|
|
static auto r1 = registerCommand<CmdRepl>("repl");
|
2016-02-23 22:19:49 +00:00
|
|
|
|
2013-09-02 15:53:58 +00:00
|
|
|
}
|