mirror of
https://github.com/NixOS/nix
synced 2025-06-28 13:41:15 +02:00
4feb7d9f71
Also move `SourcePath` into `libutil`. These changes allow `error.hh` and `error.cc` to access source path and position information, which we can use to produce better error messages (for example, we could consider omitting filenames when two or more consecutive stack frames originate from the same file).
532 lines
13 KiB
C++
532 lines
13 KiB
C++
#include "nixexpr.hh"
|
|
#include "derivations.hh"
|
|
#include "eval.hh"
|
|
#include "symbol-table.hh"
|
|
#include "util.hh"
|
|
#include "print.hh"
|
|
|
|
#include <cstdlib>
|
|
|
|
namespace nix {
|
|
|
|
ExprBlackHole eBlackHole;
|
|
|
|
// FIXME: remove, because *symbols* are abstract and do not have a single
|
|
// textual representation; see printIdentifier()
|
|
std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
|
|
{
|
|
std::string_view s = symbol;
|
|
return printIdentifier(str, s);
|
|
}
|
|
|
|
void Expr::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
abort();
|
|
}
|
|
|
|
void ExprInt::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << v.integer;
|
|
}
|
|
|
|
void ExprFloat::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << v.fpoint;
|
|
}
|
|
|
|
void ExprString::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
printLiteralString(str, s);
|
|
}
|
|
|
|
void ExprPath::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << s;
|
|
}
|
|
|
|
void ExprVar::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << symbols[name];
|
|
}
|
|
|
|
void ExprSelect::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "(";
|
|
e->show(symbols, str);
|
|
str << ")." << showAttrPath(symbols, attrPath);
|
|
if (def) {
|
|
str << " or (";
|
|
def->show(symbols, str);
|
|
str << ")";
|
|
}
|
|
}
|
|
|
|
void ExprOpHasAttr::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "((";
|
|
e->show(symbols, str);
|
|
str << ") ? " << showAttrPath(symbols, attrPath) << ")";
|
|
}
|
|
|
|
void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
if (recursive) str << "rec ";
|
|
str << "{ ";
|
|
typedef const decltype(attrs)::value_type * Attr;
|
|
std::vector<Attr> sorted;
|
|
for (auto & i : attrs) sorted.push_back(&i);
|
|
std::sort(sorted.begin(), sorted.end(), [&](Attr a, Attr b) {
|
|
std::string_view sa = symbols[a->first], sb = symbols[b->first];
|
|
return sa < sb;
|
|
});
|
|
for (auto & i : sorted) {
|
|
if (i->second.inherited)
|
|
str << "inherit " << symbols[i->first] << " " << "; ";
|
|
else {
|
|
str << symbols[i->first] << " = ";
|
|
i->second.e->show(symbols, str);
|
|
str << "; ";
|
|
}
|
|
}
|
|
for (auto & i : dynamicAttrs) {
|
|
str << "\"${";
|
|
i.nameExpr->show(symbols, str);
|
|
str << "}\" = ";
|
|
i.valueExpr->show(symbols, str);
|
|
str << "; ";
|
|
}
|
|
str << "}";
|
|
}
|
|
|
|
void ExprList::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "[ ";
|
|
for (auto & i : elems) {
|
|
str << "(";
|
|
i->show(symbols, str);
|
|
str << ") ";
|
|
}
|
|
str << "]";
|
|
}
|
|
|
|
void ExprLambda::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "(";
|
|
if (hasFormals()) {
|
|
str << "{ ";
|
|
bool first = true;
|
|
for (auto & i : formals->formals) {
|
|
if (first) first = false; else str << ", ";
|
|
str << symbols[i.name];
|
|
if (i.def) {
|
|
str << " ? ";
|
|
i.def->show(symbols, str);
|
|
}
|
|
}
|
|
if (formals->ellipsis) {
|
|
if (!first) str << ", ";
|
|
str << "...";
|
|
}
|
|
str << " }";
|
|
if (arg) str << " @ ";
|
|
}
|
|
if (arg) str << symbols[arg];
|
|
str << ": ";
|
|
body->show(symbols, str);
|
|
str << ")";
|
|
}
|
|
|
|
void ExprCall::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << '(';
|
|
fun->show(symbols, str);
|
|
for (auto e : args) {
|
|
str << ' ';
|
|
e->show(symbols, str);
|
|
}
|
|
str << ')';
|
|
}
|
|
|
|
void ExprLet::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "(let ";
|
|
for (auto & i : attrs->attrs)
|
|
if (i.second.inherited) {
|
|
str << "inherit " << symbols[i.first] << "; ";
|
|
}
|
|
else {
|
|
str << symbols[i.first] << " = ";
|
|
i.second.e->show(symbols, str);
|
|
str << "; ";
|
|
}
|
|
str << "in ";
|
|
body->show(symbols, str);
|
|
str << ")";
|
|
}
|
|
|
|
void ExprWith::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "(with ";
|
|
attrs->show(symbols, str);
|
|
str << "; ";
|
|
body->show(symbols, str);
|
|
str << ")";
|
|
}
|
|
|
|
void ExprIf::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "(if ";
|
|
cond->show(symbols, str);
|
|
str << " then ";
|
|
then->show(symbols, str);
|
|
str << " else ";
|
|
else_->show(symbols, str);
|
|
str << ")";
|
|
}
|
|
|
|
void ExprAssert::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "assert ";
|
|
cond->show(symbols, str);
|
|
str << "; ";
|
|
body->show(symbols, str);
|
|
}
|
|
|
|
void ExprOpNot::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "(! ";
|
|
e->show(symbols, str);
|
|
str << ")";
|
|
}
|
|
|
|
void ExprConcatStrings::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
bool first = true;
|
|
str << "(";
|
|
for (auto & i : *es) {
|
|
if (first) first = false; else str << " + ";
|
|
i.second->show(symbols, str);
|
|
}
|
|
str << ")";
|
|
}
|
|
|
|
void ExprPos::show(const SymbolTable & symbols, std::ostream & str) const
|
|
{
|
|
str << "__curPos";
|
|
}
|
|
|
|
|
|
std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath)
|
|
{
|
|
std::ostringstream out;
|
|
bool first = true;
|
|
for (auto & i : attrPath) {
|
|
if (!first) out << '.'; else first = false;
|
|
if (i.symbol)
|
|
out << symbols[i.symbol];
|
|
else {
|
|
out << "\"${";
|
|
i.expr->show(symbols, out);
|
|
out << "}\"";
|
|
}
|
|
}
|
|
return out.str();
|
|
}
|
|
|
|
|
|
/* Computing levels/displacements for variables. */
|
|
|
|
void Expr::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
abort();
|
|
}
|
|
|
|
void ExprInt::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
}
|
|
|
|
void ExprFloat::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
}
|
|
|
|
void ExprString::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
}
|
|
|
|
void ExprPath::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
}
|
|
|
|
void ExprVar::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
fromWith = nullptr;
|
|
|
|
/* Check whether the variable appears in the environment. If so,
|
|
set its level and displacement. */
|
|
const StaticEnv * curEnv;
|
|
Level level;
|
|
int withLevel = -1;
|
|
for (curEnv = env.get(), level = 0; curEnv; curEnv = curEnv->up, level++) {
|
|
if (curEnv->isWith) {
|
|
if (withLevel == -1) withLevel = level;
|
|
} else {
|
|
auto i = curEnv->find(name);
|
|
if (i != curEnv->vars.end()) {
|
|
this->level = level;
|
|
displ = i->second;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Otherwise, the variable must be obtained from the nearest
|
|
enclosing `with'. If there is no `with', then we can issue an
|
|
"undefined variable" error now. */
|
|
if (withLevel == -1)
|
|
throw UndefinedVarError({
|
|
.msg = hintfmt("undefined variable '%1%'", es.symbols[name]),
|
|
.errPos = es.positions[pos]
|
|
});
|
|
for (auto * e = env.get(); e && !fromWith; e = e->up)
|
|
fromWith = e->isWith;
|
|
this->level = withLevel;
|
|
}
|
|
|
|
void ExprSelect::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
e->bindVars(es, env);
|
|
if (def) def->bindVars(es, env);
|
|
for (auto & i : attrPath)
|
|
if (!i.symbol)
|
|
i.expr->bindVars(es, env);
|
|
}
|
|
|
|
void ExprOpHasAttr::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
e->bindVars(es, env);
|
|
for (auto & i : attrPath)
|
|
if (!i.symbol)
|
|
i.expr->bindVars(es, env);
|
|
}
|
|
|
|
void ExprAttrs::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
if (recursive) {
|
|
auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), recursive ? attrs.size() : 0);
|
|
|
|
Displacement displ = 0;
|
|
for (auto & i : attrs)
|
|
newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
|
|
|
|
// No need to sort newEnv since attrs is in sorted order.
|
|
|
|
for (auto & i : attrs)
|
|
i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
|
|
|
|
for (auto & i : dynamicAttrs) {
|
|
i.nameExpr->bindVars(es, newEnv);
|
|
i.valueExpr->bindVars(es, newEnv);
|
|
}
|
|
}
|
|
else {
|
|
for (auto & i : attrs)
|
|
i.second.e->bindVars(es, env);
|
|
|
|
for (auto & i : dynamicAttrs) {
|
|
i.nameExpr->bindVars(es, env);
|
|
i.valueExpr->bindVars(es, env);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ExprList::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
for (auto & i : elems)
|
|
i->bindVars(es, env);
|
|
}
|
|
|
|
void ExprLambda::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
auto newEnv = std::make_shared<StaticEnv>(
|
|
nullptr, env.get(),
|
|
(hasFormals() ? formals->formals.size() : 0) +
|
|
(!arg ? 0 : 1));
|
|
|
|
Displacement displ = 0;
|
|
|
|
if (arg) newEnv->vars.emplace_back(arg, displ++);
|
|
|
|
if (hasFormals()) {
|
|
for (auto & i : formals->formals)
|
|
newEnv->vars.emplace_back(i.name, displ++);
|
|
|
|
newEnv->sort();
|
|
|
|
for (auto & i : formals->formals)
|
|
if (i.def) i.def->bindVars(es, newEnv);
|
|
}
|
|
|
|
body->bindVars(es, newEnv);
|
|
}
|
|
|
|
void ExprCall::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
fun->bindVars(es, env);
|
|
for (auto e : args)
|
|
e->bindVars(es, env);
|
|
}
|
|
|
|
void ExprLet::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), attrs->attrs.size());
|
|
|
|
Displacement displ = 0;
|
|
for (auto & i : attrs->attrs)
|
|
newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
|
|
|
|
// No need to sort newEnv since attrs->attrs is in sorted order.
|
|
|
|
for (auto & i : attrs->attrs)
|
|
i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
|
|
|
|
body->bindVars(es, newEnv);
|
|
}
|
|
|
|
void ExprWith::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
parentWith = nullptr;
|
|
for (auto * e = env.get(); e && !parentWith; e = e->up)
|
|
parentWith = e->isWith;
|
|
|
|
/* Does this `with' have an enclosing `with'? If so, record its
|
|
level so that `lookupVar' can look up variables in the previous
|
|
`with' if this one doesn't contain the desired attribute. */
|
|
const StaticEnv * curEnv;
|
|
Level level;
|
|
prevWith = 0;
|
|
for (curEnv = env.get(), level = 1; curEnv; curEnv = curEnv->up, level++)
|
|
if (curEnv->isWith) {
|
|
prevWith = level;
|
|
break;
|
|
}
|
|
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
attrs->bindVars(es, env);
|
|
auto newEnv = std::make_shared<StaticEnv>(this, env.get());
|
|
body->bindVars(es, newEnv);
|
|
}
|
|
|
|
void ExprIf::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
cond->bindVars(es, env);
|
|
then->bindVars(es, env);
|
|
else_->bindVars(es, env);
|
|
}
|
|
|
|
void ExprAssert::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
cond->bindVars(es, env);
|
|
body->bindVars(es, env);
|
|
}
|
|
|
|
void ExprOpNot::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
e->bindVars(es, env);
|
|
}
|
|
|
|
void ExprConcatStrings::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
|
|
for (auto & i : *this->es)
|
|
i.second->bindVars(es, env);
|
|
}
|
|
|
|
void ExprPos::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
|
|
{
|
|
if (es.debugRepl)
|
|
es.exprEnvs.insert(std::make_pair(this, env));
|
|
}
|
|
|
|
|
|
/* Storing function names. */
|
|
|
|
void Expr::setName(Symbol name)
|
|
{
|
|
}
|
|
|
|
|
|
void ExprLambda::setName(Symbol name)
|
|
{
|
|
this->name = name;
|
|
body->setName(name);
|
|
}
|
|
|
|
|
|
std::string ExprLambda::showNamePos(const EvalState & state) const
|
|
{
|
|
std::string id(name
|
|
? concatStrings("'", state.symbols[name], "'")
|
|
: "anonymous function");
|
|
return fmt("%1% at %2%", id, state.positions[pos]);
|
|
}
|
|
|
|
|
|
|
|
/* Symbol table. */
|
|
|
|
size_t SymbolTable::totalSize() const
|
|
{
|
|
size_t n = 0;
|
|
dump([&] (const std::string & s) { n += s.size(); });
|
|
return n;
|
|
}
|
|
|
|
}
|