lix/src/libexpr/nixexpr.cc

609 lines
15 KiB
C++
Raw Normal View History

#include "nixexpr.hh"
#include "derivations.hh"
#include "eval.hh"
#include "symbol-table.hh"
#include "util.hh"
#include "value/print.hh"
#include <cstdlib>
namespace nix {
struct PosAdapter : AbstractPos
{
Pos::Origin origin;
PosAdapter(Pos::Origin origin)
: origin(std::move(origin))
{
}
std::optional<std::string> getSource() const override
{
return std::visit(overloaded {
[](const Pos::none_tag &) -> std::optional<std::string> {
return std::nullopt;
},
[](const Pos::Stdin & s) -> std::optional<std::string> {
// Get rid of the null terminators added by the parser.
return std::string(s.source->c_str());
},
[](const Pos::String & s) -> std::optional<std::string> {
// Get rid of the null terminators added by the parser.
return std::string(s.source->c_str());
},
[](const Path & path) -> std::optional<std::string> {
try {
return readFile(path);
} catch (Error &) {
return std::nullopt;
}
}
}, origin);
}
void print(std::ostream & out) const override
{
std::visit(overloaded {
[&](const Pos::none_tag &) { out << "«none»"; },
[&](const Pos::Stdin &) { out << "«stdin»"; },
[&](const Pos::String & s) { out << "«string»"; },
[&](const Path & path) { out << path; }
}, origin);
}
};
Pos::operator std::shared_ptr<AbstractPos>() const
{
auto pos = std::make_shared<PosAdapter>(origin);
pos->line = line;
pos->column = column;
return pos;
}
/* Displaying abstract syntax trees. */
std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
2014-10-20 06:44:32 +00:00
{
std::string_view s = symbol;
if (s.empty())
str << "\"\"";
else if (s == "if") // FIXME: handle other keywords
2014-10-20 06:44:32 +00:00
str << '"' << s << '"';
else {
char c = s[0];
if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')) {
2023-04-16 10:56:31 +00:00
printLiteralString(str, s);
return str;
2014-10-20 06:44:32 +00:00
}
for (auto c : s)
if (!((c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') ||
c == '_' || c == '\'' || c == '-')) {
2023-04-16 10:56:31 +00:00
printLiteralString(str, s);
return str;
2014-10-20 06:44:32 +00:00
}
str << s;
}
return str;
}
void Expr::show(const SymbolTable & symbols, std::ostream & str) const
2010-04-12 22:03:27 +00:00
{
abort();
}
void ExprInt::show(const SymbolTable & symbols, std::ostream & str) const
{
str << n;
}
void ExprFloat::show(const SymbolTable & symbols, std::ostream & str) const
{
str << nf;
}
void ExprString::show(const SymbolTable & symbols, std::ostream & str) const
{
2023-04-16 10:56:31 +00:00
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
2010-04-12 21:21:24 +00:00
{
str << "((";
e->show(symbols, str);
str << ") ? " << showAttrPath(symbols, attrPath) << ")";
2010-04-12 21:21:24 +00:00
}
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;
2015-07-17 17:24:28 +00:00
for (auto & i : formals->formals) {
if (first) first = false; else str << ", ";
str << symbols[i.name];
if (i.def) {
str << " ? ";
i.def->show(symbols, str);
}
}
2014-10-20 06:44:32 +00:00
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
{
2014-10-20 06:44:32 +00:00
str << "(let ";
2015-07-17 17:24:28 +00:00
for (auto & i : attrs->attrs)
if (i.second.inherited) {
str << "inherit " << symbols[i.first] << "; ";
2014-10-20 06:44:32 +00:00
}
else {
str << symbols[i.first] << " = ";
i.second.e->show(symbols, str);
str << "; ";
2014-10-20 06:44:32 +00:00
}
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
2010-04-12 21:21:24 +00:00
{
str << "assert ";
cond->show(symbols, str);
str << "; ";
body->show(symbols, str);
2010-04-12 21:21:24 +00:00
}
void ExprOpNot::show(const SymbolTable & symbols, std::ostream & str) const
2010-04-12 21:21:24 +00:00
{
str << "(! ";
e->show(symbols, str);
str << ")";
2010-04-12 21:21:24 +00:00
}
void ExprConcatStrings::show(const SymbolTable & symbols, std::ostream & str) const
2010-04-12 21:21:24 +00:00
{
bool first = true;
2014-10-20 06:44:32 +00:00
str << "(";
2015-07-17 17:24:28 +00:00
for (auto & i : *es) {
2010-04-12 21:21:24 +00:00
if (first) first = false; else str << " + ";
i.second->show(symbols, str);
2010-04-12 21:21:24 +00:00
}
2014-10-20 06:44:32 +00:00
str << ")";
2010-04-12 21:21:24 +00:00
}
void ExprPos::show(const SymbolTable & symbols, std::ostream & str) const
{
str << "__curPos";
}
2010-04-12 21:21:24 +00:00
std::ostream & operator << (std::ostream & str, const Pos & pos)
{
if (auto pos2 = (std::shared_ptr<AbstractPos>) pos) {
str << *pos2;
} else
2010-04-12 21:21:24 +00:00
str << "undefined position";
2010-04-12 21:21:24 +00:00
return str;
}
std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath)
{
std::ostringstream out;
bool first = true;
2015-03-06 13:24:08 +00:00
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)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
}
void ExprFloat::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
}
void ExprString::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
}
void ExprPath::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
}
void ExprVar::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
/* Check whether the variable appears in the environment. If so,
set its level and displacement. */
2021-10-22 20:49:58 +00:00
const StaticEnv * curEnv;
2020-02-24 13:33:01 +00:00
Level level;
2021-10-22 20:49:58 +00:00
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);
2021-10-22 20:49:58 +00:00
if (i != curEnv->vars.end()) {
fromWith = false;
this->level = level;
displ = i->second;
return;
}
}
}
2021-10-22 20:49:58 +00:00
/* 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. */
2022-04-29 17:24:54 +00:00
if (withLevel == -1)
2021-10-22 20:49:58 +00:00
throw UndefinedVarError({
.msg = hintfmt("undefined variable '%1%'", es.symbols[name]),
.errPos = es.positions[pos]
2021-10-22 20:49:58 +00:00
});
fromWith = true;
this->level = withLevel;
}
void ExprSelect::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
e->bindVars(es, env);
if (def) def->bindVars(es, env);
2015-07-17 17:24:28 +00:00
for (auto & i : attrPath)
if (!i.symbol)
i.expr->bindVars(es, env);
}
void ExprOpHasAttr::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
e->bindVars(es, env);
2015-07-17 17:24:28 +00:00
for (auto & i : attrPath)
if (!i.symbol)
i.expr->bindVars(es, env);
}
void ExprAttrs::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
if (recursive) {
auto newEnv = std::make_shared<StaticEnv>(false, env.get(), recursive ? attrs.size() : 0);
2013-09-02 14:29:15 +00:00
2020-02-24 13:33:01 +00:00
Displacement displ = 0;
2015-07-17 17:24:28 +00:00
for (auto & i : attrs)
2021-11-30 21:15:02 +00:00
newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
// No need to sort newEnv since attrs is in sorted order.
2013-09-02 14:29:15 +00:00
2015-07-17 17:24:28 +00:00
for (auto & i : attrs)
i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
2021-09-15 22:16:53 +00:00
for (auto & i : dynamicAttrs) {
i.nameExpr->bindVars(es, newEnv);
i.valueExpr->bindVars(es, newEnv);
2021-09-15 22:16:53 +00:00
}
}
2021-09-15 22:16:53 +00:00
else {
2015-07-17 17:24:28 +00:00
for (auto & i : attrs)
i.second.e->bindVars(es, env);
Dynamic attrs This adds new syntax for attribute names: * attrs."${name}" => getAttr name attrs * attrs ? "${name}" => isAttrs attrs && hasAttr attrs name * attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def * { "${name}" = value; } => listToAttrs [{ inherit name value; }] Of course, it's a bit more complicated than that. The attribute chains can be arbitrarily long and contain combinations of static and dynamic parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively straightforward for the getAttrs/hasAttrs cases but is more complex for the listToAttrs case due to rules about duplicate attribute definitions. For attribute sets with dynamic attribute names, duplicate static attributes are detected at parse time while duplicate dynamic attributes are detected when the attribute set is forced. So, for example, { a = null; a.b = null; "${"c"}" = true; } will be a parse-time error, while { a = {}; "${"a"}".b = null; c = true; } will be an eval-time error (technically that case could theoretically be detected at parse time, but the general case would require full evaluation). Moreover, duplicate dynamic attributes are not allowed even in cases where they would be with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but { a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction might be relaxed in the future in cases where the static variant would not be an error, but it is not obvious that that is desirable. Finally, recursive attribute sets with dynamic attributes have the static attributes in scope but not the dynamic ones. So rec { a = true; "${"b"}" = a; } is equivalent to { a = true; b = true; } but rec { "${"a"}" = true; b = a; } would be an error or use a from the surrounding scope if it exists. Note that the getAttr, getAttr or default, and hasAttr are all implemented purely in the parser as syntactic sugar, while attribute sets with dynamic attribute names required changes to the AST to be implemented cleanly. This is an alternative solution to and closes #167 Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
2021-09-15 22:16:53 +00:00
for (auto & i : dynamicAttrs) {
i.nameExpr->bindVars(es, env);
i.valueExpr->bindVars(es, env);
2021-09-15 22:16:53 +00:00
}
Dynamic attrs This adds new syntax for attribute names: * attrs."${name}" => getAttr name attrs * attrs ? "${name}" => isAttrs attrs && hasAttr attrs name * attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def * { "${name}" = value; } => listToAttrs [{ inherit name value; }] Of course, it's a bit more complicated than that. The attribute chains can be arbitrarily long and contain combinations of static and dynamic parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively straightforward for the getAttrs/hasAttrs cases but is more complex for the listToAttrs case due to rules about duplicate attribute definitions. For attribute sets with dynamic attribute names, duplicate static attributes are detected at parse time while duplicate dynamic attributes are detected when the attribute set is forced. So, for example, { a = null; a.b = null; "${"c"}" = true; } will be a parse-time error, while { a = {}; "${"a"}".b = null; c = true; } will be an eval-time error (technically that case could theoretically be detected at parse time, but the general case would require full evaluation). Moreover, duplicate dynamic attributes are not allowed even in cases where they would be with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but { a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction might be relaxed in the future in cases where the static variant would not be an error, but it is not obvious that that is desirable. Finally, recursive attribute sets with dynamic attributes have the static attributes in scope but not the dynamic ones. So rec { a = true; "${"b"}" = a; } is equivalent to { a = true; b = true; } but rec { "${"a"}" = true; b = a; } would be an error or use a from the surrounding scope if it exists. Note that the getAttr, getAttr or default, and hasAttr are all implemented purely in the parser as syntactic sugar, while attribute sets with dynamic attribute names required changes to the AST to be implemented cleanly. This is an alternative solution to and closes #167 Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
}
}
void ExprList::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
2015-07-17 17:24:28 +00:00
for (auto & i : elems)
i->bindVars(es, env);
}
void ExprLambda::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
auto newEnv = std::make_shared<StaticEnv>(
false, env.get(),
(hasFormals() ? formals->formals.size() : 0) +
(!arg ? 0 : 1));
2013-09-02 14:29:15 +00:00
2020-02-24 13:33:01 +00:00
Displacement displ = 0;
2013-09-02 14:29:15 +00:00
if (arg) newEnv->vars.emplace_back(arg, displ++);
if (hasFormals()) {
2015-07-17 17:24:28 +00:00
for (auto & i : formals->formals)
2021-11-30 21:15:02 +00:00
newEnv->vars.emplace_back(i.name, displ++);
2021-11-30 21:15:02 +00:00
newEnv->sort();
2015-07-17 17:24:28 +00:00
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)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
fun->bindVars(es, env);
for (auto e : args)
e->bindVars(es, env);
}
void ExprLet::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-11-25 15:53:59 +00:00
auto newEnv = std::make_shared<StaticEnv>(false, env.get(), attrs->attrs.size());
2013-09-02 14:29:15 +00:00
2020-02-24 13:33:01 +00:00
Displacement displ = 0;
2015-07-17 17:24:28 +00:00
for (auto & i : attrs->attrs)
2021-11-30 21:15:02 +00:00
newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
// No need to sort newEnv since attrs->attrs is in sorted order.
2013-09-02 14:29:15 +00:00
2015-07-17 17:24:28 +00:00
for (auto & i : attrs->attrs)
i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
2013-09-02 14:29:15 +00:00
body->bindVars(es, newEnv);
}
void ExprWith::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
2010-04-14 15:01:04 +00:00
/* 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. */
2010-04-14 15:01:04 +00:00
const StaticEnv * curEnv;
2020-02-24 13:33:01 +00:00
Level level;
prevWith = 0;
2021-09-14 16:49:22 +00:00
for (curEnv = env.get(), level = 1; curEnv; curEnv = curEnv->up, level++)
2010-04-14 15:01:04 +00:00
if (curEnv->isWith) {
prevWith = level;
break;
}
2013-09-02 14:29:15 +00:00
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
attrs->bindVars(es, env);
auto newEnv = std::make_shared<StaticEnv>(true, env.get());
body->bindVars(es, newEnv);
}
void ExprIf::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
cond->bindVars(es, env);
then->bindVars(es, env);
else_->bindVars(es, env);
}
void ExprAssert::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
cond->bindVars(es, env);
body->bindVars(es, env);
}
void ExprOpNot::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
e->bindVars(es, env);
}
void ExprConcatStrings::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
if (es.debugRepl)
es.exprEnvs.insert(std::make_pair(this, env));
2021-10-02 19:47:36 +00:00
for (auto & i : *this->es)
i.second->bindVars(es, env);
}
void ExprPos::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
{
2022-05-23 03:45:24 +00:00
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;
}
}