guiwf/lix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c76cf496293602e55ff3aae5bda3e422ebbf4f10
lix/lix/libcmd/repl.cc
T
Tom Hubrecht cbeb4fcd69 repl: Fix the use command 
The culprit was a space added at the wrong place, which messed with c++
raw strings.

Fixes #1178

Change-Id: Ic1e09cb7215d9a6dd2d13fd92242649b0e1fcd13
2026-04-07 11:02:53 +02:00

1737 lines
58 KiB
C++
Raw Blame History

#include <algorithm>
#include <cstdio>
#include <editline.h>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <optional>
#include <string_view>
#include "libutil/logging.hh"
#include "lix/libexpr/value.hh"
#include "lix/libutil/box_ptr.hh"
#include "lix/libcmd/repl-interacter.hh"
#include "lix/libcmd/repl.hh"
#include "lix/libutil/ansicolor.hh"
#include "lix/libmain/shared.hh"
#include "lix/libexpr/eval.hh"
#include "lix/libexpr/eval-settings.hh"
#include "lix/libexpr/attr-path.hh"
#include "lix/libutil/signals.hh"
#include "lix/libstore/store-api.hh"
#include "lix/libstore/log-store.hh"
#include "lix/libcmd/common-eval-args.hh"
#include "lix/libexpr/get-drvs.hh"
#include "lix/libstore/derivations.hh"
#include "lix/libstore/globals.hh"
#include "lix/libexpr/flake/flake.hh"
#include "lix/libexpr/flake/lockfile.hh"
#include "lix/libcmd/editor-for.hh"
#include "lix/libutil/finally.hh"
#include "lix/libcmd/markdown.hh"
#include "lix/libstore/local-fs-store.hh"
#include "lix/libutil/signals.hh"
#include "lix/libexpr/print.hh"
#include "lix/libexpr/gc-small-vector.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/users.hh"
#if HAVE_BOEHMGC
#define GC_INCLUDE_NEW
#include <gc/gc_cpp.h>
#endif
// XXX: These are for lix-doc features and will be removed in a future rewrite where this functionality is integrated more natively.
extern "C" {
char const *lixdoc_get_function_docs(char const *filename, size_t line, size_t col);
void lixdoc_free_string(char const *str);
}
namespace nix {
/** Wrapper around std::unique_ptr with a custom deleter for strings from nix-doc **/
using NdString = std::unique_ptr<const char, decltype(&lixdoc_free_string)>;
/**
* Fetch a string representing the doc comment using nix-doc and wrap it in an RAII wrapper.
*/
NdString lambdaDocsForPos(SourcePath const path, nix::Pos const &pos) {
std::string const file = path.to_string();
// NOLINTNEXTLINE(lix-unsafe-c-calls): paths are safe
return NdString{lixdoc_get_function_docs(file.c_str(), pos.line, pos.column), &lixdoc_free_string};
}
/**
* Returned by `NixRepl::processLine`.
*/
enum class ProcessLineResult {
/**
* The user exited with `:quit`. The REPL should exit. The surrounding
* program or evaluation (e.g., if the REPL was acting as the debugger)
* should also exit.
*/
Quit,
/**
* The user exited with `:continue`. The REPL should exit, but the program
* should continue running.
*/
Continue,
/**
* The user did not exit. The REPL should request another line of input.
*/
PromptAgain,
};
using namespace std::literals::string_view_literals;
enum class ReplLoadKind
{
File,
Flake,
};
// std::variant or virtual inheritence would both be overkill for this.
struct ReplLoadable
{
std::string spec;
ReplLoadKind kind;
friend constexpr auto operator<=>(ReplLoadable const &, ReplLoadable const &) = default;
};
struct NixRepl;
using ReplFunction = std::function<ProcessLineResult(NixRepl &, const std::string &)>;
using PrintDerivationOutputFunction =
std::function<std::string(const std::string &, const StorePath &)>;
struct CommandArgumentSpecifier
{
std::string placeholderText;
bool optional = false;
};
static const CommandArgumentSpecifier argExpr = {.placeholderText = "expr"};
static const CommandArgumentSpecifier argPath = {.placeholderText = "path"};
struct CommandAttributes
{
std::list<std::string> aliases;
/**
* Whether this command can only be used inside of the debugger.
*/
bool debugModeOnly;
std::optional<std::string> help;
std::optional<std::string> section;
std::list<CommandArgumentSpecifier> positionalArgsSpecifiers;
};
struct REPLCommand
{
ReplFunction handler;
CommandAttributes attributes;
};
struct UnexpectedArgument : Error
{
std::string argValue;
UnexpectedArgument(const std::string & argValue)
: Error("unexpected argument")
, argValue(argValue)
{
}
};
struct ReplEnv
{
Env * env;
int displ;
LinearMap<Symbol, Displacement> vars;
StringSet varNames;
};
struct NixRepl
: AbstractNixRepl
, detail::ReplCompleterMixin
#if HAVE_BOEHMGC
, gc
#endif
{
Evaluator & evaluator;
size_t debugTraceIndex;
std::list<ReplLoadable> loaded;
std::function<AnnotatedValues()> getValues;
std::map<std::string, std::shared_ptr<REPLCommand>> registeredCommands;
// Uses 8MiB of memory. It's fine.
const static int envSize = 1 << 20;
std::shared_ptr<StaticEnv> staticEnv;
Env * env;
int displ;
StringSet varNames;
box_ptr<ReplInteracter> interacter;
NixRepl(const SearchPath & searchPath, nix::ref<Store> store, EvalState & state,
std::function<AnnotatedValues()> getValues);
virtual ~NixRepl() = default;
ReplExitStatus mainLoop() override;
void initEnv() override;
/** Swaps our `env`, `displ`, `staticEnv->vars`, and `varNames` values
* with the ones provided in @param swapWith.
*/
void swapEnv(ReplEnv & swapWith);
void initDebugBuiltinCommands();
void initBuiltinCommands();
virtual StringSet completePrefix(const std::string & prefix) override;
/**
* @exception nix::Error thrown directly if the expression does not evaluate
* to a derivation, or evaluates to an invalid derivation.
*/
StorePath getDerivationPath(Value & v);
/**
* Evaluate a string argument into a store path.
*/
StorePath evalIntoDerivationPath(const std::string & drvArg);
/**
* Build a derivation path and show a progress bar for it.
*/
Derivation buildWithProgressBar(const StorePath & drvPath);
/**
* Print the derivation outputs produced by a derivation.
* A function that should return the string for each output can be passed
* to customize the formatting and perform additional actions such as adding permanent roots.
*/
void printDerivationOutputs(const StorePath & drvPath, PrintDerivationOutputFunction printFn);
ProcessLineResult processLine(std::string line);
bool inDebugger() const
{
return evaluator.debug && evaluator.debug->inDebugger;
}
void loadFile(const Path & path);
void loadFlake(const std::string & flakeRef);
void loadFiles(std::list<ReplLoadable> const & loadables);
void reloadFiles();
void addCommand(
const std::string & name,
ReplFunction && function,
const CommandAttributes & attributes = {}
);
void generateHelpCommand();
template<typename T, typename NameFn, typename ValueFn>
void addToScope(T && things, NameFn nameFn, ValueFn valueFn);
void addAttrsToScope(Value & attrs);
void addValMapToScope(const ValMap & attrs);
void addVarToScope(const Symbol name, Value & v);
Expr & parseString(std::string s);
std::variant<std::unique_ptr<Expr>, ExprReplBindings> parseReplString(std::string s);
Value evalString(std::string s);
void loadDebugTraceEnv(const DebugTrace & dt);
/**
* Load the `repl-overlays` and add the resulting AttrSet to the top-level
* bindings.
*/
void loadReplOverlays();
/**
* Get a list of each of the `repl-overlays` (parsed and evaluated).
*/
Value replOverlays();
/**
* Get the Nix function that composes the `repl-overlays` together.
*/
Value getReplOverlaysEvalFunction();
/**
* Cached return value of `getReplOverlaysEvalFunction`.
*
* Note: This is `shared_ptr` to avoid garbage collection.
*/
std::shared_ptr<std::optional<Value>> replOverlaysEvalFunction =
std::allocate_shared<std::optional<Value>>(
TraceableAllocator<std::optional<Value>>(), std::nullopt
);
/**
* Get the `info` AttrSet that's passed as the first argument to each
* of the `repl-overlays`.
*/
Value replInitInfo();
/**
* Get the current top-level bindings as an AttrSet.
*/
Value bindingsToAttrs();
/**
* Parse a file, evaluate its result, and force the resulting value.
*/
Value evalFile(SourcePath & path);
void printValue(std::ostream & str,
Value & v,
unsigned int maxDepth = std::numeric_limits<unsigned int>::max(),
unsigned int derivationPathDepth = 0)
{
::nix::printValue(state, str, v, PrintOptions {
.ansiColors = true,
.force = true,
.derivationPathDepth = derivationPathDepth,
.maxDepth = maxDepth,
.prettyIndent = 2,
.errors = ErrorPrintBehavior::ThrowTopLevel,
});
}
};
std::string removeWhitespace(std::string s)
{
s = chomp(s);
size_t n = s.find_first_not_of(" \n\r\t");
if (n != std::string::npos) s = std::string(s, n);
return s;
}
static box_ptr<ReplInteracter> makeInteracter() {
if (experimentalFeatureSettings.isEnabled(Xp::ReplAutomation))
return make_box_ptr<AutomationInteracter>();
else
return make_box_ptr<ReadlineLikeInteracter>(getDataDir() + "/nix/repl-history");
}
NixRepl::NixRepl(const SearchPath & searchPath, nix::ref<Store> store, EvalState & state,
std::function<NixRepl::AnnotatedValues()> getValues)
: AbstractNixRepl(state)
, evaluator(state.ctx)
, debugTraceIndex(0)
, getValues(getValues)
, staticEnv(new StaticEnv(nullptr, evaluator.builtins.staticEnv.get()))
, interacter(makeInteracter())
{
initBuiltinCommands();
}
void runNix(Path program, const Strings & args)
{
auto subprocessEnv = getEnv();
subprocessEnv["NIX_CONFIG"] = globalConfig.toKeyValue(true);
runProgram2(RunOptions {
.program = settings.nixBinDir+ "/" + program,
.args = args,
.environment = subprocessEnv,
}).waitAndCheck();
return;
}
static std::ostream & showDebugTrace(std::ostream & out, const PosTable & positions, const DebugTrace & dt)
{
if (dt.isError)
out << ANSI_RED "error: " << ANSI_NORMAL;
out << dt.hint.str() << "\n";
// prefer direct pos, but if noPos then try the expr.
auto pos = dt.pos
? dt.pos
: positions[dt.expr.getPos() ? dt.expr.getPos() : noPos];
if (pos) {
out << *pos;
if (auto loc = pos->getCodeLines()) {
out << "\n";
printCodeLines(out, "", *pos, *loc);
out << "\n";
}
}
return out;
}
static bool isFirstRepl = true;
ReplExitStatus NixRepl::mainLoop()
{
if (isFirstRepl) {
std::string_view debuggerNotice = "";
if (inDebugger()) {
debuggerNotice = " debugger";
}
notice("Lix %1%%2%\nType :? for help.", Uncolored(nixVersion), debuggerNotice);
}
isFirstRepl = false;
std::list<ReplLoadable> loadables = std::exchange(loaded, {});
loadFiles(loadables);
auto _guard = interacter->init(static_cast<detail::ReplCompleterMixin *>(this));
/* Stop the progress bar because it interferes with the display of
the repl. */
logger->pause();
std::string input;
while (true) {
unsetUserInterruptRequest();
// When continuing input from previous lines, don't print a prompt, just align to the same
// number of chars as the prompt.
if (!interacter->getLine(input, input.empty() ? ReplPromptType::ReplPrompt : ReplPromptType::ContinuationPrompt)) {
// Ctrl-D should exit the debugger.
if (evaluator.debug) {
evaluator.debug->stop = false;
}
logger->cout("");
// TODO: Should Ctrl-D exit just the current debugger session or
// the entire program?
return ReplExitStatus::QuitAll;
}
try {
switch (processLine(input)) {
case ProcessLineResult::Quit:
return ReplExitStatus::QuitAll;
case ProcessLineResult::Continue:
return ReplExitStatus::Continue;
case ProcessLineResult::PromptAgain:
break;
default:
abort();
}
} catch (ParseError & e) {
if (e.msg().find("unexpected end of file") != 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, "%1%", Uncolored(e.msg()));
}
} catch (EvalError & e) {
printMsg(lvlError, "%1%", Uncolored(e.msg()));
} catch (Error & e) {
printMsg(lvlError, "%1%", Uncolored(e.msg()));
} catch (Interrupted & e) {
printMsg(lvlError, "%1%", Uncolored(e.msg()));
}
// We handled the current input fully, so we should clear it
// and read brand new input.
input.clear();
std::cout << std::endl;
}
}
StringSet NixRepl::completePrefix(const std::string &prefix)
{
StringSet completions;
// We should only complete colon commands if there's a colon at the beginning,
// but editline (for... whatever reason) doesn't *give* us the colon in the
// completion callback. If the user types :rel<TAB>, `prefix` will only be `rel`.
// Luckily, editline provides a global variable for its current buffer, so we can
// check for the presence of a colon there.
if (rl_line_buffer != nullptr && rl_line_buffer[0] == ':') {
for (auto const & [colonCmd, cmd] : registeredCommands) {
if ((!cmd->attributes.debugModeOnly || inDebugger()) && colonCmd.starts_with(prefix)) {
completions.insert(std::string(colonCmd));
}
}
// If there were : command completions, then we should only return those,
// because otherwise this is not valid Nix syntax.
// However if we didn't get any completions, then this could be something
// like `:b pkgs.hel<TAB>`, in which case we should do expression completion
// as normal.
if (!completions.empty()) {
return completions;
}
}
size_t start = prefix.find_last_of(" \n\r\t(){}[]");
std::string prev, cur;
if (start == std::string::npos) {
prev = "";
cur = prefix;
} else {
prev = std::string(prefix, 0, start + 1);
cur = std::string(prefix, start + 1);
}
size_t slash, dot;
if ((slash = cur.rfind('/')) != std::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] != '.' && entry.name.starts_with(prefix2))
completions.insert(prev + dir + "/" + entry.name);
}
} catch (Error &) {
}
} else if ((dot = cur.rfind('.')) == std::string::npos) {
/* This is a variable name; look it up in the current scope. */
StringSet::iterator i = varNames.lower_bound(cur);
while (i != varNames.end()) {
if (i->substr(0, cur.size()) != cur) break;
completions.insert(prev + *i);
i++;
}
} else {
// To handle cases like `foo."bar.`, walk back the cursor
// to the previous dot if there are an odd number of quotes.
auto quoteCount =
std::count_if(cur.begin(), cur.begin() + dot, [](char c) { return c == '"'; });
if (quoteCount % 2 != 0) {
// Find the last quote before the dot
auto prevQuote = cur.rfind('"', dot - 1);
if (prevQuote != std::string::npos) {
// And the previous dot prior to that quote
auto prevDot = cur.rfind('.', prevQuote);
if (prevDot != std::string::npos) {
dot = prevDot;
}
}
}
/* Temporarily disable the debugger, to avoid re-entering readline. */
auto debug = std::move(evaluator.debug);
Finally restoreDebug([&]() { evaluator.debug = std::move(debug); });
try {
/* This is an expression that should evaluate to an
attribute set. Evaluate it to get the names of the
attributes. */
auto expr = cur.substr(0, dot);
auto cur2 = cur.substr(dot + 1);
Expr & e = parseString(expr);
Value v = e.eval(state, *env);
state.forceAttrs(v, noPos, "while evaluating an attrset for the purpose of completion (this error should not be displayed; file an issue?)");
for (auto & i : *v.attrs()) {
std::ostringstream output;
printAttributeName(output, evaluator.symbols[i.name]);
std::string name = output.str();
if (name.substr(0, cur2.size()) != cur2) continue;
completions.insert(concatStrings(prev, expr, ".", name));
}
} catch (ParseError & e) {
// Quietly ignore parse errors.
} catch (EvalError & e) {
// Quietly ignore evaluation errors.
} catch (BadURL & e) {
// Quietly ignore BadURL flake-related errors.
} catch (SysError & e) {
// Quietly ignore system errors which can for example be raised by
// a non-existent file being `import`-ed.
}
}
return completions;
}
StorePath NixRepl::getDerivationPath(Value & v) {
auto drvInfo = getDerivation(state, v, false);
if (!drvInfo)
throw Error("expression does not evaluate to a derivation, so I can't build it");
auto drvPath = drvInfo->queryDrvPath(state);
if (!drvPath)
throw Error("expression did not evaluate to a valid derivation (no 'drvPath' attribute)");
if (!state.aio.blockOn(evaluator.store->isValidPath(*drvPath)))
throw Error("expression evaluated to invalid derivation '%s'", evaluator.store->printStorePath(*drvPath));
return *drvPath;
}
StorePath NixRepl::evalIntoDerivationPath(const std::string & drvArg)
{
Value v = evalString(drvArg);
return getDerivationPath(v);
}
Derivation NixRepl::buildWithProgressBar(const StorePath & drvPath)
{
// TODO: this only shows a progress bar for explicitly initiated builds,
// not eval-time fetching or builds performed for IFD.
// But we can't just show it everywhere, since that would erase partial output from evaluation.
logger->resetProgress();
logger->resume();
Finally stopLogger([&]() { logger->pause(); });
state.aio.blockOn(evaluator.store->buildPaths({
DerivedPath::Built{
.drvPath = makeConstantStorePath(drvPath),
.outputs = OutputsSpec::All{},
},
}));
auto drv = state.aio.blockOn(evaluator.store->readDerivation(drvPath));
return drv;
}
void NixRepl::printDerivationOutputs(
const StorePath & drvPath, PrintDerivationOutputFunction printFn
)
{
logger->cout("\nThis derivation produced the following outputs:");
for (auto & [outputName, outputPath] :
state.aio.blockOn(evaluator.store->queryDerivationOutputMap(drvPath)))
{
logger->cout(printFn(outputName, outputPath));
}
}
void NixRepl::loadDebugTraceEnv(const DebugTrace & dt)
{
initEnv();
auto se = evaluator.debug->staticEnvFor(dt.expr);
if (se) {
auto vm = mapStaticEnvBindings(evaluator.symbols, *se.get(), dt.env);
// add staticenv vars.
addValMapToScope(*vm);
}
}
void NixRepl::addCommand(
const std::string & name, ReplFunction && handler, const CommandAttributes & attributes
)
{
if (registeredCommands.contains(name)) {
throw Error("Command '%s' is already registered: commands cannot be shadowed", name);
}
registeredCommands[name] = std::make_shared<REPLCommand>(std::move(handler), attributes);
for (auto & alias : attributes.aliases) {
if (registeredCommands.contains(alias)) {
throw Error(
"Command '%s' is already registered: alias (original command '%s') cannot shadow other "
"commands",
name,
alias
);
}
registeredCommands[alias] = registeredCommands[name];
}
}
ProcessLineResult NixRepl::processLine(std::string line)
{
line = trim(line);
if (line.empty())
return ProcessLineResult::PromptAgain;
std::string command, arg;
if (line[0] == ':') {
size_t p = line.find_first_of(" \n\r\t");
command = line.substr(1, p - 1);
if (p != std::string::npos) arg = removeWhitespace(line.substr(p));
} else {
arg = line;
}
if (registeredCommands.contains(command)) {
auto registeredCommand = registeredCommands[command];
try {
if (registeredCommand->attributes.debugModeOnly && !inDebugger()) {
throw Error("command '%s' can only be used when the debugger is active", command);
}
return registeredCommand->handler(*this, arg);
} catch (UnexpectedArgument & excArg) {
throw Error("unexpected argument '%1%' to command '%2%", excArg.argValue, command);
}
} else if (command != "") {
throw Error("unknown command '%1%'", command);
} else {
/* A line is either a regular expression or a `var = expr` assignment */
std::variant<std::unique_ptr<Expr>, ExprReplBindings> result = parseReplString(line);
std::visit(
overloaded{
[&](ExprReplBindings & b) {
for (auto & [name, e] : b.symbols) {
Value v = e->eval(state, *env);
// NONEXTLINE(bugprone-unused-return-value): leak because of thunk
// references
(void) e.release();
addVarToScope(name, v);
}
},
[&](std::unique_ptr<Expr> & e) {
Value v = e->eval(state, *env);
// NONEXTLINE(bugprone-unused-return-value): leak because of thunk references
(void) e.release();
state.forceValue(v, noPos);
printValue(std::cout, v, 1);
std::cout << std::endl;
}
},
result
);
}
return ProcessLineResult::PromptAgain;
}
void NixRepl::initDebugBuiltinCommands()
{
addCommand(
"backtrace",
[](NixRepl & repl, const std::string & _arg) {
auto traces = repl.evaluator.debug->traces();
for (const auto & [idx, i] : enumerate(traces)) {
std::cout << "\n" << ANSI_BLUE << idx << ANSI_NORMAL << ": ";
showDebugTrace(std::cout, repl.evaluator.positions, *i);
}
return ProcessLineResult::PromptAgain;
},
{.aliases = {"bt"},
.debugModeOnly = true,
.help = "Show trace stack",
.section = "Debug mode"}
);
addCommand(
"show-trace",
// this command has a bit of nuance to its function and error states.
// it can either:
// 1. be called without any argument
// -> just display the current stack frame (still have to walk up the stack :/)
// 2. be called with an absolute index
// -> try to go to that frame
// -> if it doesn't exist, print an "arg out of range" error
// 3. be called with a relative index
// -> if the final offset is in-bounds, go to that frame
// -> otherwise: clamp the index, i.e. go to 0/$max instead of out-of-bounds
//
// because the collection of frames is lazy and isn't a random-access list,
// we need to iterate the whole stack for most of these if we want to have
// good error messages; this is the biggest reason why this function is so
// long/complex compared to its role
//
[](NixRepl & repl, const std::string & arg) {
auto setTrace = [&](size_t traceIdx, const DebugTrace * trace) {
repl.debugTraceIndex = traceIdx;
std::cout << "\n" << ANSI_BLUE << traceIdx << ANSI_NORMAL << ": ";
showDebugTrace(std::cout, repl.evaluator.positions, *trace);
std::cout << std::endl;
printEnvBindings(repl.state, trace->expr, trace->env);
repl.loadDebugTraceEnv(*trace);
};
// tries to find a trace at a given index.
// - if it is found, it returns the requested trace, along with its
// index, which will be *the same* as requested
// - otherwise, it returns the last (=outermost) trace, along with
// its index, which will be *different* than the one requested
auto tryFindTrace = [&](size_t traceIdx) -> std::pair<size_t, const DebugTrace *> {
size_t lastIndex = 0;
const DebugTrace * lastTrace;
auto traces = repl.evaluator.debug->traces();
for (const auto & [idx, i] : enumerate(traces)) {
lastTrace = i;
lastIndex = idx;
if (idx == traceIdx) {
return std::pair(idx, i);
}
}
return std::pair(lastIndex, lastTrace);
};
bool isRelativeIdx = false;
int requestedTraceIdx;
if (arg.length() == 0) {
// if there's no argument, just re-print the current frame
requestedTraceIdx = repl.debugTraceIndex;
} else {
std::optional<int> maybeIdx = string2Int<int>(arg);
if (!maybeIdx) {
throw Error("argument '%s' is not a valid integer", arg);
}
isRelativeIdx = arg.starts_with('+') || arg.starts_with('-');
requestedTraceIdx =
isRelativeIdx ? maybeIdx.value() + repl.debugTraceIndex : maybeIdx.value();
}
auto [actualTraceIdx, trace] = tryFindTrace((size_t) requestedTraceIdx);
// if we *did* find the frame we wanted originally, all is well
// in the world and we can just load it and exit
if (actualTraceIdx == (size_t) requestedTraceIdx) {
setTrace(actualTraceIdx, trace);
return ProcessLineResult::PromptAgain;
}
// if we couldn't immediately find the requested trace on the "happy path", then either:
// a) it was an absolute index but didn't exist
// -> print a specific error showing the exact valid range
if (!isRelativeIdx) {
throw Error(
"stack index must be between %ld and %ld (inclusive), but was %ld",
0,
actualTraceIdx, // tryFindTrace sets *idx to the final (max) frame index if it fails
requestedTraceIdx
);
}
// b) it was a relative index
// -> clamp the index to the bounds and print a warning
if (requestedTraceIdx < 0) {
// just load frame 0 but print a warning about the bounds
std::tie(actualTraceIdx, trace) = tryFindTrace(0);
setTrace(actualTraceIdx, trace);
printTaggedWarning("stopped at stack frame %ld, cannot go any deeper", 0);
return ProcessLineResult::PromptAgain;
} else {
// (if we're here, then requestedTraceIdx > $max, since tryFindTrace failed)
// load the max frame (that `tryFindFrame` kindly already got for us),
// but print a warning that we can't go any further
setTrace(actualTraceIdx, trace);
printTaggedWarning("stopped at stack frame %ld, cannot go any higher", actualTraceIdx);
return ProcessLineResult::PromptAgain;
}
},
{.aliases = {"st"},
.debugModeOnly = true,
.help = "Show current trace. If an integer is provided, this switches to that stack "
"beforehand. If the integer has an explicit + or - sign, it is treated as"
"relative to the current stack index.",
.section = "Debug mode",
.positionalArgsSpecifiers = {{.placeholderText = "integer index", .optional = true}}}
);
addCommand(
"step",
[](NixRepl & repl, const std::string & _arg) {
repl.evaluator.debug->stop = true;
return ProcessLineResult::Continue;
},
{.aliases = {"s"}, .debugModeOnly = true, .help = "Go one step", .section = "Debug mode"}
);
addCommand(
"continue",
[](NixRepl & repl, const std::string & _arg) {
repl.evaluator.debug->stop = false;
return ProcessLineResult::Continue;
},
{.aliases = {"c"},
.debugModeOnly = true,
.help = "Go until end of program, exception or builtins.break",
.section = "Debug mode"}
);
}
void NixRepl::initBuiltinCommands()
{
initDebugBuiltinCommands();
addCommand(
"add",
[](NixRepl & repl, const std::string & arg) {
Value v = repl.evalString(arg);
repl.addAttrsToScope(v);
return ProcessLineResult::PromptAgain;
},
{.aliases = {"a"},
.help = "Add attributes from resulting set to scope",
.positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"load",
[](NixRepl & repl, const std::string & arg) {
repl.state.resetFileCache();
repl.loadFile(arg);
return ProcessLineResult::PromptAgain;
},
{
.aliases = {"l"},
.help = "Load Nix expression and add it to scope",
.positionalArgsSpecifiers = {argPath},
}
);
addCommand(
"reload",
[](NixRepl & repl, const std::string & _arg) {
repl.state.resetFileCache();
repl.reloadFiles();
return ProcessLineResult::PromptAgain;
},
{.aliases = {"r"}, .help = "Reload all files successfully loaded"}
);
addCommand(
"edit",
[](NixRepl & repl, const std::string & arg) {
Value v = repl.evalString(arg);
const auto [path, line] = [&]() -> std::pair<SourcePath, uint32_t> {
if (v.type() == nPath || v.type() == nString) {
NixStringContext context;
auto path = repl.state.coerceToPath(
noPos, v, context, "while evaluating the filename to edit"
);
return {path, 0};
} else if (v.isLambda()) {
auto pos = repl.evaluator.positions[v.lambda().fun->pos];
if (auto path = std::get_if<CheckedSourcePath>(&pos.origin)) {
return {*path, pos.line};
}
throw Error("'%s' cannot be shown in an editor", pos);
} else {
return findPackageFilename(repl.state, v, arg);
}
}();
auto args = editorFor(path, line);
auto editor = args.front();
args.pop_front();
runProgram2(RunOptions{.program = editor, .searchPath = true, .args = args})
.waitAndCheck();
if (!repl.evaluator.store->isInStore(canonPath(path.canonical().abs(), true))) {
repl.state.resetFileCache();
repl.reloadFiles();
}
return ProcessLineResult::PromptAgain;
},
{
.aliases = {"e"},
.help = "Open package or function in $EDITOR",
.positionalArgsSpecifiers = {argExpr},
}
);
addCommand(
"type",
[](NixRepl & repl, const std::string & arg) {
Value v = repl.evalString(arg);
logger->cout(showType(v));
return ProcessLineResult::PromptAgain;
},
{
.aliases = {"t"},
.help = "Describe result of evaluation",
.positionalArgsSpecifiers = {argExpr},
}
);
addCommand(
"use",
[](NixRepl & repl, const std::string & arg) {
Value v = repl.evalString(arg);
Value f = repl.evalString(
R"(drv: (import <nixpkgs> {}).runCommand "shell" { buildInputs = [ drv ]; } "")"
);
Value result = repl.state.callFunction(f, v, PosIdx());
StorePath drvPath = repl.getDerivationPath(result);
runNix("nix-shell", {repl.evaluator.store->printStorePath(drvPath)});
return ProcessLineResult::PromptAgain;
},
{.aliases = {"u"},
.help = "Build derivation, then start nix-shell",
.positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"log",
[](NixRepl & repl, const std::string & arg) {
if (arg.empty()) {
throw Error("cannot use ':log' without specifying a derivation");
}
StorePath drvPath = ([&] {
auto maybeDrvPath = repl.evaluator.store->maybeParseStorePath(arg);
if (maybeDrvPath && maybeDrvPath->isDerivation()) {
return std::move(*maybeDrvPath);
} else {
Value v = repl.evalString(arg);
return repl.getDerivationPath(v);
}
})();
Path drvPathRaw = repl.evaluator.store->printStorePath(drvPath);
settings.readOnlyMode = true;
Finally roReset([&]() { settings.readOnlyMode = false; });
auto subs = repl.state.aio.blockOn(getDefaultSubstituters());
subs.push_front(repl.evaluator.store);
bool foundLog = false;
withPager([&](Pager & pager) {
for (auto & sub : subs) {
auto * logSubP = dynamic_cast<LogStore *>(&*sub);
if (!logSubP) {
printInfo("Skipped '%s' which does not support retrieving build logs", sub->getUri());
continue;
}
auto & logSub = *logSubP;
auto log = repl.state.aio.blockOn(logSub.getBuildLog(drvPath));
if (log) {
printInfo("got build log for '%s' from '%s'", drvPathRaw, logSub.getUri());
pager << *log;
foundLog = true;
break;
}
}
if (!foundLog) {
throw Error("build log of '%s' is not available", drvPathRaw);
}
});
return ProcessLineResult::PromptAgain;
},
{.help = "Show logs for a derivation",
.positionalArgsSpecifiers = {{.placeholderText = "expr | .drv path"}}}
);
addCommand(
"build",
[](NixRepl & repl, const std::string & arg) {
auto drvPath = repl.evalIntoDerivationPath(arg);
auto drv = repl.buildWithProgressBar(drvPath);
repl.printDerivationOutputs(
drvPath, [&repl](const std::string & outputName, const StorePath & outputPath) {
return fmt(
" %s -> %s", outputName, repl.evaluator.store->printStorePath(outputPath)
);
}
);
return ProcessLineResult::PromptAgain;
},
{.aliases = {"b"}, .help = "Build a derivation", .positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"build-with-gc-roots",
[](NixRepl & repl, const std::string & arg) {
auto drvPath = repl.evalIntoDerivationPath(arg);
auto drv = repl.buildWithProgressBar(drvPath);
repl.printDerivationOutputs(
drvPath, [&repl](const std::string & outputName, const StorePath & outputPath) {
auto localStore = repl.evaluator.store.try_cast_shared<LocalFSStore>();
std::string symlink = fmt("repl-result-%s", outputName);
repl.state.aio.blockOn(localStore->addPermRoot(outputPath, absPath(symlink)));
return fmt(
" ./%s -> %s", symlink, repl.evaluator.store->printStorePath(outputPath)
);
}
);
return ProcessLineResult::PromptAgain;
},
{.aliases = {"bl"},
.help = "Build a derivation, creating GC roots in the working directory",
.positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"build-and-install",
[](NixRepl & repl, const std::string & arg) {
Path drvPathRaw =
repl.evaluator.store->printStorePath(repl.evalIntoDerivationPath(arg));
runNix("nix-env", {"-i", drvPathRaw});
return ProcessLineResult::PromptAgain;
},
{.aliases = {"i"},
.help = "Build derivation, then install result into current profile",
.positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"shell",
[](NixRepl & repl, const std::string & arg) {
Path drvPathRaw =
repl.evaluator.store->printStorePath(repl.evalIntoDerivationPath(arg));
runNix("nix-shell", {drvPathRaw});
return ProcessLineResult::PromptAgain;
},
{.aliases = {"sh"},
.help = "Build dependencies of derivation, then start nix-shell",
.positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"print",
[](NixRepl & repl, const std::string & arg) {
Value v = repl.evalString(arg);
if (v.type() == nString) {
std::cout << v.str();
} else if (v.type() == nAttrs && repl.state.isDerivation(v)) {
repl.printValue(std::cout, v, 2, 1);
} else {
repl.printValue(std::cout, v, std::numeric_limits<unsigned int>::max(), 0);
}
std::cout << std::endl;
return ProcessLineResult::PromptAgain;
},
{.aliases = {"p"},
.help = "Evaluate and print expression recursively\n"
"Strings are printed directly, without escaping.",
.positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"quit",
[](NixRepl & repl, const std::string & _arg) {
if (repl.evaluator.debug) {
repl.evaluator.debug->stop = false;
}
return ProcessLineResult::Quit;
},
{.aliases = {"q"}, .help = "Exit the REPL"}
);
addCommand(
"doc",
[](NixRepl & repl, const std::string & arg) {
Value v = repl.evalString(arg);
if (auto doc = repl.evaluator.builtins.getDoc(v)) {
std::string markdown;
if (!doc->args.empty() && doc->name) {
auto args = doc->args;
for (auto & arg : args) {
arg = "*" + arg + "*";
}
markdown += "**Synopsis:** `builtins." + (std::string) *doc->name + "` "
+ concatStringsSep(" ", args) + "\n\n";
}
markdown += stripIndentation(doc->doc);
logger->cout(trim(renderMarkdownToTerminal(markdown)));
} else if (v.isLambda()) {
auto pos = repl.evaluator.positions[v.lambda().fun->pos];
if (auto path = std::get_if<CheckedSourcePath>(&pos.origin)) {
auto docComment = lambdaDocsForPos(*path, pos);
if (!docComment) {
throw Error("lambda '%s' has no documentation comment", pos);
}
std::string markdown = stripIndentation(docComment.get());
logger->cout(trim(renderMarkdownToTerminal(markdown)));
} else {
throw Error("lambda '%s' doesn't have a determinable source file", pos);
}
} else {
throw Error("value '%s' does not have documentation", arg);
}
return ProcessLineResult::PromptAgain;
},
{.help = "Show documentation for the provided function (experimental lambda support)",
.positionalArgsSpecifiers = {argExpr}}
);
addCommand(
"trace-enable",
[](NixRepl & repl, const std::string & arg) {
if (arg == "false" || (arg == "" && loggerSettings.showTrace)) {
std::cout << "not showing error traces\n";
loggerSettings.showTrace.override(false);
} else if (arg == "true" || (arg == "" && !loggerSettings.showTrace)) {
std::cout << "showing error traces\n";
loggerSettings.showTrace.override(true);
} else {
throw UnexpectedArgument(arg);
}
return ProcessLineResult::PromptAgain;
},
{.aliases = {"te"},
.help = "Enable, disable, or toggle showing traces for errors",
.positionalArgsSpecifiers = {{.placeholderText = "bool", .optional = true}}}
);
addCommand(
"env",
[](NixRepl & repl, const std::string & _arg) {
if (repl.inDebugger()) {
auto traces = repl.evaluator.debug->traces();
for (const auto & [idx, i] : enumerate(traces)) {
if (idx == repl.debugTraceIndex) {
printEnvBindings(repl.state, i->expr, i->env);
break;
}
}
} else {
printEnvBindings(repl.state.ctx.symbols, *repl.staticEnv, *repl.env, 0);
}
return ProcessLineResult::PromptAgain;
},
{.help = "Show environment stack"}
);
addCommand(
"load-flake",
[](NixRepl & repl, const std::string & arg) {
repl.loadFlake(arg);
return ProcessLineResult::PromptAgain;
},
{.aliases = {"lf"},
.help = "Load Nix flake and add it to the scope",
.section = "Flakes",
.positionalArgsSpecifiers = {{.placeholderText = "flakeref"}}}
);
generateHelpCommand();
}
static Strings wrapText(const std::string & text, size_t width)
{
Strings lines, inputLines;
inputLines = tokenizeString<Strings>(text, "\n");
for (auto & line : inputLines) {
// Preserve empty lines
if (line.empty()) {
lines.emplace_back("");
continue;
}
std::string wrappedLine;
Strings words = tokenizeString<Strings>(line, " ");
for (auto & word : words) {
if (wrappedLine.size() + word.size() + 1 > width) {
lines.push_back(wrappedLine);
wrappedLine.clear();
}
if (!wrappedLine.empty()) {
wrappedLine += " ";
}
wrappedLine += word;
}
if (!wrappedLine.empty()) {
lines.push_back(wrappedLine);
}
}
return lines;
}
void NixRepl::generateHelpCommand()
{
addCommand(
"help",
[](NixRepl & repl, const std::string & _arg) {
// Special entries appear at the top, general entries stems from command registration.
std::map<std::string, std::string> generalEntries, specialEntries;
std::map<std::string, std::map<std::string, std::string>> perSectionEntries;
std::cout << "The following commands are available:\n"
<< "\n";
specialEntries["<expr>"] = "Evaluate and print expression";
specialEntries["<x> = <expr>"] = "Bind expression to variable";
size_t maxLhsWidth = 20;
for (auto & [name, command] : repl.registeredCommands) {
auto aliases = command->attributes.aliases;
bool isAlias = std::find(aliases.begin(), aliases.end(), name) != aliases.end();
if (command->attributes.debugModeOnly && !repl.inDebugger()) {
continue;
}
if (isAlias) {
continue;
}
auto lhs = concatMapStringsSep(", ", aliases, [](const std::string & alias) {
return ":" + alias;
});
if (!lhs.empty()) {
lhs += ", ";
}
lhs += ":";
lhs += name;
if (!command->attributes.positionalArgsSpecifiers.empty()) {
lhs += " ";
}
lhs += concatMapStringsSep(
" ",
command->attributes.positionalArgsSpecifiers,
[](const CommandArgumentSpecifier & specifier) {
if (specifier.optional) {
return "[" + specifier.placeholderText + "]";
} else {
return "<" + specifier.placeholderText + ">";
}
}
);
maxLhsWidth = std::max(maxLhsWidth, lhs.size() + 5);
auto helpText =
command->attributes.help.value_or("No help text is provided for this command.");
if (!command->attributes.section) {
generalEntries[lhs] = helpText;
} else {
perSectionEntries[*command->attributes.section][lhs] = helpText;
}
}
const size_t totalWidth = std::get<1>(getWindowSize());
const size_t lhsWidth = maxLhsWidth;
// 2 + 1 spaces
const size_t rhsWidth = std::max(static_cast<size_t>(0), totalWidth - lhsWidth - 3);
auto printSection = [lhsWidth,
rhsWidth](const std::map<std::string, std::string> & entries) {
for (auto & [lhs, rhs] : entries) {
auto wrapped = wrapText(rhs, rhsWidth);
for (auto const [index, wrappedComponent] : enumerate(wrapped)) {
if (index == 0) {
// 2 + 1 spaces
auto compensatedLhsWidth = std::max(static_cast<size_t>(0), lhsWidth - 3);
std::cout
<< std::format(" {:<{}} {}\n", lhs, compensatedLhsWidth, wrappedComponent);
} else {
// only 1 space
auto compensatedLhsWidth = std::max(static_cast<size_t>(0), lhsWidth - 1);
std::cout
<< std::format("{:<{}} {}\n", " ", compensatedLhsWidth, wrappedComponent);
}
}
}
};
printSection(specialEntries);
printSection(generalEntries);
for (auto & [section, entries] : perSectionEntries) {
std::cout << "\n " << section << " commands\n" << std::endl;
printSection(entries);
}
return ProcessLineResult::PromptAgain;
},
{
.aliases = {"?"},
.help = "Print help about all commands (this content)",
}
);
}
void NixRepl::loadFile(const Path & path)
{
ReplLoadable loadable{
.spec = path,
.kind = ReplLoadKind::File,
};
try {
loaded.remove(loadable);
loaded.push_back(loadable);
Value v = state.evalFile(state.aio.blockOn(lookupFileArg(evaluator, path)).unwrap(always_progresses));
Value v2 = state.autoCallFunction(*autoArgs, v, noPos);
addAttrsToScope(v2);
} catch (...) {
// In case of failure, do not keep the loaded path.
// Let the user reload it again later.
loaded.remove(loadable);
throw;
}
}
void NixRepl::loadFlake(const std::string & flakeRefS)
{
if (flakeRefS.empty())
throw Error("cannot use ':load-flake' without a path specified. (Use '.' for the current working directory.)");
auto flakeRef = parseFlakeRef(flakeRefS, absPath("."), true);
if (evalSettings.pureEval && !flakeRef.input.isLocked())
throw Error("cannot use ':load-flake' on locked flake reference '%s' (use --impure to override)", flakeRefS);
ReplLoadable loadable{
.spec = flakeRefS,
.kind = ReplLoadKind::Flake,
};
try {
loaded.remove(loadable);
loaded.push_back(loadable);
Value v = flake::callFlake(
state,
flake::lockFlake(
state,
flakeRef,
flake::LockFlags{
.updateLockFile = false,
.useRegistries = !evalSettings.pureEval,
.allowUnlocked = !evalSettings.pureEval,
}
)
);
addAttrsToScope(v);
} catch (...) {
// In case of failure, do not keep the flake reference.
// Let the user re-load it again later.
loaded.remove(loadable);
throw;
}
}
/** Creates the stuff for a fresh, empty REPL environment. */
ReplEnv initNewEnv(Evaluator & evaluator, int envSize)
{
Env * newEnv = &evaluator.mem.allocEnv(envSize);
newEnv->up = &evaluator.builtins.env;
int newDispl = 0;
LinearMap<Symbol, Displacement> newVars;
StringSet newVarNames;
for (auto && [key, _] : evaluator.builtins.staticEnv->vars) {
newVarNames.emplace(evaluator.symbols[key]);
}
return {
.env = newEnv,
.displ = newDispl,
.vars = newVars,
.varNames = newVarNames,
};
}
void NixRepl::swapEnv(ReplEnv & swapWith)
{
std::swap(env, swapWith.env);
std::swap(displ, swapWith.displ);
std::swap(staticEnv->vars, swapWith.vars);
std::swap(varNames, swapWith.varNames);
}
void NixRepl::initEnv()
{
auto && newEnv = initNewEnv(evaluator, envSize);
swapEnv(newEnv);
}
void NixRepl::reloadFiles()
{
auto && newEnv = initNewEnv(evaluator, envSize);
swapEnv(newEnv);
std::list<ReplLoadable> saved = std::exchange(loaded, {});
try {
loadFiles(saved);
} catch (Error const & e) {
// Stop loading on the first error, but restore the environment so errors
// don't throw everything away.
swapEnv(newEnv);
std::swap(loaded, saved);
throw;
}
}
void NixRepl::loadFiles(std::list<ReplLoadable> const & loadables)
{
for (auto const & [spec, kind] : loadables) {
switch (kind) {
case ReplLoadKind::File:
notice("Loading '%s'...", Magenta(spec));
loadFile(spec);
break;
case ReplLoadKind::Flake:
notice("Loading flake reference '%s'...", Magenta(spec));
loadFlake(spec);
break;
}
}
for (auto & [i, what] : getValues()) {
notice("Loading installable '%1%'...", Magenta(what));
addAttrsToScope(i);
}
loadReplOverlays();
}
void NixRepl::loadReplOverlays()
{
if (evalSettings.replOverlays.get().empty()) {
return;
}
notice("Loading '%1%'...", "repl-overlays");
auto replInitFilesFunction = getReplOverlaysEvalFunction();
Value args[] = {replInitInfo(), bindingsToAttrs(), replOverlays()};
Value newAttrs = state.callFunction(replInitFilesFunction, args, noPos);
// n.b. this does in fact load the stuff into the environment twice (once
// from the superset of the environment returned by repl-overlays and once
// from the thing itself), but it's not fixable because clearEnv here could
// lead to dangling references to the old environment in thunks.
// https://git.lix.systems/lix-project/lix/issues/337#issuecomment-3745
addAttrsToScope(newAttrs);
}
Value NixRepl::getReplOverlaysEvalFunction()
{
if (replOverlaysEvalFunction && *replOverlaysEvalFunction) {
return **replOverlaysEvalFunction;
}
auto evalReplInitFilesPath = CanonPath::root + "repl-overlays.nix";
auto code =
#include "repl-overlays.nix.gen.hh"
;
auto & expr = evaluator.parseExprFromString(
code,
SourcePath(evalReplInitFilesPath),
evaluator.builtins.staticEnv
);
*replOverlaysEvalFunction = state.eval(expr);
return **replOverlaysEvalFunction;
}
Value NixRepl::replOverlays()
{
auto replInitStorage = evaluator.mem.newList(evalSettings.replOverlays.get().size());
Value replInits = {NewValueAs::list, replInitStorage};
size_t i = 0;
for (auto path : evalSettings.replOverlays.get()) {
debug("Loading '%1%' path '%2%'...", "repl-overlays", path);
SourcePath sourcePath((CanonPath(path)));
// XXX(jade): This is a somewhat unsatisfying solution to
// https://git.lix.systems/lix-project/lix/issues/777 which means that
// the top level item in the repl-overlays file (that is, the lambda)
// gets evaluated with pure eval off. This means that if you want to do
// impure eval stuff, you will have to force it with builtins.seq.
bool prevPureEval = evalSettings.pureEval.get();
auto replInit = evalFile(sourcePath);
evalSettings.pureEval.setDefault(prevPureEval);
if (!replInit.isLambda()) {
evaluator.errors
.make<TypeError>(
"Expected `repl-overlays` entry %s to be a lambda but found %s: %s",
path,
showType(replInit),
ValuePrinter(state, replInit, errorPrintOptions)
)
.debugThrow();
}
if (auto attrs = dynamic_cast<AttrsPattern *>(replInit.lambda().fun->pattern.get());
attrs && !attrs->ellipsis)
{
evaluator.errors
.make<TypeError>(
"Expected first argument of %1% to have %2% to allow future versions of Lix to "
"add additional attributes to the argument",
"repl-overlays",
"..."
)
.atPos(replInit.lambda().fun->pos)
.debugThrow();
}
replInitStorage->elems[i] = replInit;
i++;
}
return replInits;
}
Value NixRepl::replInitInfo()
{
auto builder = evaluator.buildBindings(2);
Value currentSystem = {NewValueAs::string, evalSettings.getCurrentSystem()};
builder.insert(evaluator.symbols.create("currentSystem"), currentSystem);
return {NewValueAs::attrs, builder.finish()};
}
template<typename T, typename NameFn, typename ValueFn>
void NixRepl::addToScope(T && things, NameFn nameFn, ValueFn valueFn)
{
size_t added = 0;
staticEnv->vars.unsafe_insert_bulk([&] (auto & map) {
auto oldSize = map.size();
for (auto && thing : things) {
if (displ + 1 >= envSize)
throw Error("environment full; cannot add more variables");
const auto name = nameFn(thing);
map.emplace_back(name, displ);
env->values[displ++] = valueFn(thing);
varNames.emplace(evaluator.symbols[name]);
added++;
}
// safety: we sort the range that we inserted so that we don't have to push that
// invariant up to the caller
std::sort(map.begin() + oldSize, map.end());
});
if (added > 0) {
notice("Added %1% variables.", added);
}
}
void NixRepl::addAttrsToScope(Value & attrs)
{
state.forceAttrs(attrs, noPos, "while evaluating an attribute set to be merged in the global scope");
addToScope(
*attrs.attrs(), [](const Attr & a) { return a.name; }, [](const Attr & a) { return a.value; }
);
}
void NixRepl::addValMapToScope(const ValMap & attrs)
{
addToScope(
attrs,
[&](auto & val) { return evaluator.symbols.create(val.first); },
[&](auto & val) { return val.second; }
);
}
void NixRepl::addVarToScope(const Symbol name, Value & v)
{
if (displ >= envSize)
throw Error("environment full; cannot add more variables");
if (staticEnv->vars.insert_or_assign(name, displ).second) {
notice("Updated %s.", evaluator.symbols[name]);
} else {
notice("Added %s.", evaluator.symbols[name]);
}
env->values[displ++] = v;
varNames.emplace(evaluator.symbols[name]);
}
Value NixRepl::bindingsToAttrs()
{
auto builder = evaluator.buildBindings(staticEnv->vars.size());
for (auto & [symbol, displacement] : staticEnv->vars) {
builder.insert(symbol, env->values[displacement]);
}
return {NewValueAs::attrs, builder.finish()};
}
Expr & NixRepl::parseString(std::string s)
{
return evaluator.parseExprFromString(std::move(s), CanonPath::fromCwd(), staticEnv, featureSettings);
}
std::variant<std::unique_ptr<Expr>, ExprReplBindings> NixRepl::parseReplString(std::string s)
{
return evaluator.parseReplInput(std::move(s), CanonPath::fromCwd(), staticEnv, featureSettings);
}
Value NixRepl::evalString(std::string s)
{
Expr & e = parseString(s);
Value v = e.eval(state, *env);
state.forceValue(v, noPos);
return v;
}
Value NixRepl::evalFile(SourcePath & path)
{
auto & expr = evaluator.parseExprFromFile(evaluator.paths.checkSourcePath(path), staticEnv);
Value result = expr.eval(state, *env);
state.forceValue(result, noPos);
return result;
}
ReplExitStatus AbstractNixRepl::run(
const SearchPath & searchPath,
nix::ref<Store> store,
EvalState & state,
std::function<AnnotatedValues()> getValues,
const ValMap & extraEnv,
Bindings * autoArgs
)
{
NixRepl repl(searchPath, store, state, getValues);
repl.autoArgs = autoArgs;
repl.initEnv();
repl.addValMapToScope(extraEnv);
return repl.mainLoop();
}
ReplExitStatus AbstractNixRepl::runSimple(EvalState & evalState, const ValMap & extraEnv)
{
return run(
{},
evalState.aio.blockOn(openStore()),
evalState,
[] { return AnnotatedValues{}; },
extraEnv,
nullptr
);
}
}
Reference in New Issue View Git Blame Copy Permalink