2004-01-30 15:21:42 +00:00
|
|
|
|
%glr-parser
|
2019-10-09 20:57:37 +00:00
|
|
|
|
%define api.pure
|
2004-01-30 15:21:42 +00:00
|
|
|
|
%locations
|
2019-03-27 20:09:31 +00:00
|
|
|
|
%define parse.error verbose
|
2006-10-02 14:43:15 +00:00
|
|
|
|
%defines
|
2006-10-11 21:59:33 +00:00
|
|
|
|
/* %no-lines */
|
2013-03-14 17:31:08 +00:00
|
|
|
|
%parse-param { void * scanner }
|
|
|
|
|
%parse-param { nix::ParseData * data }
|
|
|
|
|
%lex-param { void * scanner }
|
|
|
|
|
%lex-param { nix::ParseData * data }
|
2012-04-13 12:28:26 +00:00
|
|
|
|
%expect 1
|
|
|
|
|
%expect-rr 1
|
2004-01-30 15:21:42 +00:00
|
|
|
|
|
2010-10-23 21:11:59 +00:00
|
|
|
|
%code requires {
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-10-23 21:11:59 +00:00
|
|
|
|
#ifndef BISON_HEADER
|
|
|
|
|
#define BISON_HEADER
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-01-19 12:39:42 +00:00
|
|
|
|
#include <variant>
|
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
#include "util.hh"
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
#include "nixexpr.hh"
|
2011-08-06 16:05:24 +00:00
|
|
|
|
#include "eval.hh"
|
2019-11-26 18:48:34 +00:00
|
|
|
|
#include "globals.hh"
|
2010-04-12 18:30:11 +00:00
|
|
|
|
|
2010-10-23 21:11:59 +00:00
|
|
|
|
namespace nix {
|
|
|
|
|
|
2013-09-02 14:29:15 +00:00
|
|
|
|
struct ParseData
|
2010-10-23 21:11:59 +00:00
|
|
|
|
{
|
2011-08-06 16:05:24 +00:00
|
|
|
|
EvalState & state;
|
2010-10-23 21:11:59 +00:00
|
|
|
|
SymbolTable & symbols;
|
|
|
|
|
Expr * result;
|
|
|
|
|
Path basePath;
|
2020-05-21 04:18:26 +00:00
|
|
|
|
Symbol file;
|
|
|
|
|
FileOrigin origin;
|
2021-01-20 23:27:36 +00:00
|
|
|
|
std::optional<ErrorInfo> error;
|
2011-08-06 16:05:24 +00:00
|
|
|
|
ParseData(EvalState & state)
|
|
|
|
|
: state(state)
|
|
|
|
|
, symbols(state.symbols)
|
2010-10-23 21:11:59 +00:00
|
|
|
|
{ };
|
|
|
|
|
};
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-01-19 15:49:02 +00:00
|
|
|
|
struct ParserFormals {
|
|
|
|
|
std::vector<Formal> formals;
|
|
|
|
|
bool ellipsis = false;
|
|
|
|
|
};
|
|
|
|
|
|
2010-10-23 21:11:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-01-19 12:39:42 +00:00
|
|
|
|
// using C a struct allows us to avoid having to define the special
|
|
|
|
|
// members that using string_view here would implicitly delete.
|
|
|
|
|
struct StringToken {
|
|
|
|
|
const char * p;
|
|
|
|
|
size_t l;
|
|
|
|
|
bool hasIndentation;
|
|
|
|
|
operator std::string_view() const { return {p, l}; }
|
|
|
|
|
};
|
|
|
|
|
|
2010-10-23 21:11:59 +00:00
|
|
|
|
#define YY_DECL int yylex \
|
|
|
|
|
(YYSTYPE * yylval_param, YYLTYPE * yylloc_param, yyscan_t yyscanner, nix::ParseData * data)
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
%{
|
|
|
|
|
|
2006-09-04 22:08:40 +00:00
|
|
|
|
#include "parser-tab.hh"
|
|
|
|
|
#include "lexer-tab.hh"
|
|
|
|
|
|
2010-10-23 21:11:59 +00:00
|
|
|
|
YY_DECL;
|
2006-09-04 21:36:15 +00:00
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
using namespace nix;
|
2004-01-30 15:21:42 +00:00
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
namespace nix {
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
|
2011-07-06 10:58:17 +00:00
|
|
|
|
static void dupAttr(const AttrPath & attrPath, const Pos & pos, const Pos & prevPos)
|
2010-04-22 11:02:24 +00:00
|
|
|
|
{
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("attribute '%1%' already defined at %2%",
|
|
|
|
|
showAttrPath(attrPath), prevPos),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2020-06-15 12:06:58 +00:00
|
|
|
|
});
|
2010-04-22 11:02:24 +00:00
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-05-06 16:46:48 +00:00
|
|
|
|
static void dupAttr(Symbol attr, const Pos & pos, const Pos & prevPos)
|
2010-04-22 11:02:24 +00:00
|
|
|
|
{
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("attribute '%1%' already defined at %2%", attr, prevPos),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2020-06-15 12:06:58 +00:00
|
|
|
|
});
|
2010-04-22 11:02:24 +00:00
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2009-05-15 12:35:23 +00:00
|
|
|
|
|
2013-12-31 23:56:26 +00:00
|
|
|
|
static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
|
2010-04-13 12:25:42 +00:00
|
|
|
|
Expr * e, const Pos & pos)
|
2009-05-15 12:35:23 +00:00
|
|
|
|
{
|
2013-12-31 23:56:26 +00:00
|
|
|
|
AttrPath::iterator i;
|
2013-12-31 22:57:10 +00:00
|
|
|
|
// All attrpaths have at least one attr
|
2013-12-31 23:56:26 +00:00
|
|
|
|
assert(!attrPath.empty());
|
2018-04-18 16:39:40 +00:00
|
|
|
|
// Checking attrPath validity.
|
|
|
|
|
// ===========================
|
2019-05-28 21:05:08 +00:00
|
|
|
|
for (i = attrPath.begin(); i + 1 < attrPath.end(); i++) {
|
2013-12-31 22:57:10 +00:00
|
|
|
|
if (i->symbol.set()) {
|
|
|
|
|
ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
|
|
|
|
|
if (j != attrs->attrs.end()) {
|
|
|
|
|
if (!j->second.inherited) {
|
|
|
|
|
ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
|
2013-12-31 23:56:26 +00:00
|
|
|
|
if (!attrs2) dupAttr(attrPath, pos, j->second.pos);
|
2013-12-31 22:57:10 +00:00
|
|
|
|
attrs = attrs2;
|
|
|
|
|
} else
|
2013-12-31 23:56:26 +00:00
|
|
|
|
dupAttr(attrPath, pos, j->second.pos);
|
2013-12-31 22:57:10 +00:00
|
|
|
|
} else {
|
2010-04-12 23:33:23 +00:00
|
|
|
|
ExprAttrs * nested = new ExprAttrs;
|
2013-12-31 22:57:10 +00:00
|
|
|
|
attrs->attrs[i->symbol] = ExprAttrs::AttrDef(nested, pos);
|
2010-04-12 23:33:23 +00:00
|
|
|
|
attrs = nested;
|
2006-09-04 21:36:15 +00:00
|
|
|
|
}
|
2013-12-31 22:57:10 +00:00
|
|
|
|
} else {
|
|
|
|
|
ExprAttrs *nested = new ExprAttrs;
|
|
|
|
|
attrs->dynamicAttrs.push_back(ExprAttrs::DynamicAttrDef(i->expr, nested, pos));
|
|
|
|
|
attrs = nested;
|
2009-05-15 12:35:23 +00:00
|
|
|
|
}
|
2009-05-14 14:29:45 +00:00
|
|
|
|
}
|
2018-04-18 16:39:40 +00:00
|
|
|
|
// Expr insertion.
|
|
|
|
|
// ==========================
|
2019-05-28 21:05:08 +00:00
|
|
|
|
if (i->symbol.set()) {
|
2013-12-31 22:57:10 +00:00
|
|
|
|
ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
|
|
|
|
|
if (j != attrs->attrs.end()) {
|
2018-04-18 16:39:40 +00:00
|
|
|
|
// This attr path is already defined. However, if both
|
|
|
|
|
// e and the expr pointed by the attr path are two attribute sets,
|
|
|
|
|
// we want to merge them.
|
|
|
|
|
// Otherwise, throw an error.
|
2019-05-28 21:05:08 +00:00
|
|
|
|
auto ae = dynamic_cast<ExprAttrs *>(e);
|
|
|
|
|
auto jAttrs = dynamic_cast<ExprAttrs *>(j->second.e);
|
2018-04-18 16:39:40 +00:00
|
|
|
|
if (jAttrs && ae) {
|
2019-05-28 21:05:08 +00:00
|
|
|
|
for (auto & ad : ae->attrs) {
|
|
|
|
|
auto j2 = jAttrs->attrs.find(ad.first);
|
2018-04-18 16:39:40 +00:00
|
|
|
|
if (j2 != jAttrs->attrs.end()) // Attr already defined in iAttrs, error.
|
|
|
|
|
dupAttr(ad.first, j2->second.pos, ad.second.pos);
|
2020-02-21 17:31:16 +00:00
|
|
|
|
jAttrs->attrs.emplace(ad.first, ad.second);
|
2018-04-18 16:39:40 +00:00
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
dupAttr(attrPath, pos, j->second.pos);
|
|
|
|
|
}
|
2013-12-31 22:57:10 +00:00
|
|
|
|
} else {
|
2018-04-18 16:39:40 +00:00
|
|
|
|
// This attr path is not defined. Let's create it.
|
2020-02-21 17:31:16 +00:00
|
|
|
|
attrs->attrs.emplace(i->symbol, ExprAttrs::AttrDef(e, pos));
|
2013-12-31 22:57:10 +00:00
|
|
|
|
e->setName(i->symbol);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
attrs->dynamicAttrs.push_back(ExprAttrs::DynamicAttrDef(i->expr, e, pos));
|
|
|
|
|
}
|
2009-05-14 14:29:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-01-19 15:49:02 +00:00
|
|
|
|
static Formals * toFormals(ParseData & data, ParserFormals * formals,
|
|
|
|
|
Pos pos = noPos, Symbol arg = {})
|
2009-05-14 14:29:45 +00:00
|
|
|
|
{
|
2022-01-19 15:49:02 +00:00
|
|
|
|
std::sort(formals->formals.begin(), formals->formals.end(),
|
|
|
|
|
[] (const auto & a, const auto & b) {
|
|
|
|
|
return std::tie(a.name, a.pos) < std::tie(b.name, b.pos);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
std::optional<std::pair<Symbol, Pos>> duplicate;
|
|
|
|
|
for (size_t i = 0; i + 1 < formals->formals.size(); i++) {
|
|
|
|
|
if (formals->formals[i].name != formals->formals[i + 1].name)
|
|
|
|
|
continue;
|
|
|
|
|
std::pair thisDup{formals->formals[i].name, formals->formals[i + 1].pos};
|
|
|
|
|
duplicate = std::min(thisDup, duplicate.value_or(thisDup));
|
|
|
|
|
}
|
|
|
|
|
if (duplicate)
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2022-01-19 15:49:02 +00:00
|
|
|
|
.msg = hintfmt("duplicate formal function argument '%1%'", duplicate->first),
|
|
|
|
|
.errPos = duplicate->second
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
Formals result;
|
|
|
|
|
result.ellipsis = formals->ellipsis;
|
|
|
|
|
result.formals = std::move(formals->formals);
|
|
|
|
|
|
|
|
|
|
if (arg.set() && result.has(arg))
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2022-01-19 15:49:02 +00:00
|
|
|
|
.msg = hintfmt("duplicate formal function argument '%1%'", arg),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2020-06-15 12:06:58 +00:00
|
|
|
|
});
|
2022-01-19 15:49:02 +00:00
|
|
|
|
|
|
|
|
|
delete formals;
|
|
|
|
|
return new Formals(std::move(result));
|
2009-05-14 14:29:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-01-19 12:39:42 +00:00
|
|
|
|
static Expr * stripIndentation(const Pos & pos, SymbolTable & symbols,
|
2022-02-21 15:32:34 +00:00
|
|
|
|
std::vector<std::pair<Pos, std::variant<Expr *, StringToken> > > & es)
|
2007-11-30 16:48:45 +00:00
|
|
|
|
{
|
2022-01-19 13:31:30 +00:00
|
|
|
|
if (es.empty()) return new ExprString("");
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2007-11-30 16:48:45 +00:00
|
|
|
|
/* Figure out the minimum indentation. Note that by design
|
|
|
|
|
whitespace-only final lines are not taken into account. (So
|
|
|
|
|
the " " in "\n ''" is ignored, but the " " in "\n foo''" is.) */
|
|
|
|
|
bool atStartOfLine = true; /* = seen only whitespace in the current line */
|
2018-05-02 11:56:34 +00:00
|
|
|
|
size_t minIndent = 1000000;
|
|
|
|
|
size_t curIndent = 0;
|
2021-09-23 02:30:31 +00:00
|
|
|
|
for (auto & [i_pos, i] : es) {
|
2022-01-19 12:39:42 +00:00
|
|
|
|
auto * str = std::get_if<StringToken>(&i);
|
|
|
|
|
if (!str || !str->hasIndentation) {
|
|
|
|
|
/* Anti-quotations and escaped characters end the current start-of-line whitespace. */
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (atStartOfLine) {
|
|
|
|
|
atStartOfLine = false;
|
|
|
|
|
if (curIndent < minIndent) minIndent = curIndent;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2022-01-19 12:39:42 +00:00
|
|
|
|
for (size_t j = 0; j < str->l; ++j) {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (atStartOfLine) {
|
2022-01-19 12:39:42 +00:00
|
|
|
|
if (str->p[j] == ' ')
|
2007-11-30 16:48:45 +00:00
|
|
|
|
curIndent++;
|
2022-01-19 12:39:42 +00:00
|
|
|
|
else if (str->p[j] == '\n') {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
/* Empty line, doesn't influence minimum
|
|
|
|
|
indentation. */
|
|
|
|
|
curIndent = 0;
|
|
|
|
|
} else {
|
|
|
|
|
atStartOfLine = false;
|
|
|
|
|
if (curIndent < minIndent) minIndent = curIndent;
|
|
|
|
|
}
|
2022-01-19 12:39:42 +00:00
|
|
|
|
} else if (str->p[j] == '\n') {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
atStartOfLine = true;
|
|
|
|
|
curIndent = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Strip spaces from each line. */
|
2022-02-21 15:32:34 +00:00
|
|
|
|
std::vector<std::pair<Pos, Expr *> > * es2 = new std::vector<std::pair<Pos, Expr *> >;
|
2007-11-30 16:48:45 +00:00
|
|
|
|
atStartOfLine = true;
|
2018-05-02 11:56:34 +00:00
|
|
|
|
size_t curDropped = 0;
|
|
|
|
|
size_t n = es.size();
|
2022-01-19 12:39:42 +00:00
|
|
|
|
auto i = es.begin();
|
|
|
|
|
const auto trimExpr = [&] (Expr * e) {
|
|
|
|
|
atStartOfLine = false;
|
|
|
|
|
curDropped = 0;
|
|
|
|
|
es2->emplace_back(i->first, e);
|
|
|
|
|
};
|
|
|
|
|
const auto trimString = [&] (const StringToken & t) {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string s2;
|
2022-01-19 12:39:42 +00:00
|
|
|
|
for (size_t j = 0; j < t.l; ++j) {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (atStartOfLine) {
|
2022-01-19 12:39:42 +00:00
|
|
|
|
if (t.p[j] == ' ') {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (curDropped++ >= minIndent)
|
2022-01-19 12:39:42 +00:00
|
|
|
|
s2 += t.p[j];
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
2022-01-19 12:39:42 +00:00
|
|
|
|
else if (t.p[j] == '\n') {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
curDropped = 0;
|
2022-01-19 12:39:42 +00:00
|
|
|
|
s2 += t.p[j];
|
2007-11-30 16:48:45 +00:00
|
|
|
|
} else {
|
|
|
|
|
atStartOfLine = false;
|
|
|
|
|
curDropped = 0;
|
2022-01-19 12:39:42 +00:00
|
|
|
|
s2 += t.p[j];
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
|
|
|
|
} else {
|
2022-01-19 12:39:42 +00:00
|
|
|
|
s2 += t.p[j];
|
|
|
|
|
if (t.p[j] == '\n') atStartOfLine = true;
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Remove the last line if it is empty and consists only of
|
|
|
|
|
spaces. */
|
|
|
|
|
if (n == 1) {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string::size_type p = s2.find_last_of('\n');
|
|
|
|
|
if (p != std::string::npos && s2.find_first_not_of(' ', p + 1) == std::string::npos)
|
|
|
|
|
s2 = std::string(s2, 0, p + 1);
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
2010-04-12 22:03:27 +00:00
|
|
|
|
|
2022-01-19 13:31:30 +00:00
|
|
|
|
es2->emplace_back(i->first, new ExprString(s2));
|
2022-01-19 12:39:42 +00:00
|
|
|
|
};
|
|
|
|
|
for (; i != es.end(); ++i, --n) {
|
|
|
|
|
std::visit(overloaded { trimExpr, trimString }, i->second);
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-10-16 22:57:24 +00:00
|
|
|
|
/* If this is a single string, then don't do a concatenation. */
|
2021-09-23 02:30:31 +00:00
|
|
|
|
return es2->size() == 1 && dynamic_cast<ExprString *>((*es2)[0].second) ? (*es2)[0].second : new ExprConcatStrings(pos, true, es2);
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-04-04 15:53:52 +00:00
|
|
|
|
static inline Pos makeCurPos(const YYLTYPE & loc, ParseData * data)
|
2004-04-05 22:27:41 +00:00
|
|
|
|
{
|
2020-05-21 04:18:26 +00:00
|
|
|
|
return Pos(data->origin, data->file, loc.first_line, loc.first_column);
|
2004-04-05 22:27:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-05-06 16:46:48 +00:00
|
|
|
|
#define CUR_POS makeCurPos(*yylocp, data)
|
2006-02-13 13:09:23 +00:00
|
|
|
|
|
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-02 14:43:15 +00:00
|
|
|
|
void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, const char * error)
|
2006-09-04 21:36:15 +00:00
|
|
|
|
{
|
2020-06-15 12:06:58 +00:00
|
|
|
|
data->error = {
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(error),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = makeCurPos(*loc, data)
|
2020-06-15 12:06:58 +00:00
|
|
|
|
};
|
2006-09-04 21:36:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-01-30 15:21:42 +00:00
|
|
|
|
%}
|
|
|
|
|
|
|
|
|
|
%union {
|
2013-09-02 14:29:15 +00:00
|
|
|
|
// !!! We're probably leaking stuff here.
|
2010-04-12 18:30:11 +00:00
|
|
|
|
nix::Expr * e;
|
|
|
|
|
nix::ExprList * list;
|
|
|
|
|
nix::ExprAttrs * attrs;
|
2022-01-19 15:49:02 +00:00
|
|
|
|
nix::ParserFormals * formals;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
nix::Formal * formal;
|
2013-08-19 10:35:03 +00:00
|
|
|
|
nix::NixInt n;
|
2016-01-04 23:40:40 +00:00
|
|
|
|
nix::NixFloat nf;
|
don't strdup tokens in the lexer
every stringy token the lexer returns is turned into a Symbol and not
used further, so we don't have to strdup. using a string_view is
sufficient, but due to limitations of the current parser we have to use
a POD type that holds the same information.
gives ~2% on system build, 6% on search, 8% on parsing alone
# before
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 610.6 ms ± 2.4 ms [User: 602.5 ms, System: 7.8 ms]
Range (min … max): 606.6 ms … 617.3 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 430.1 ms ± 1.4 ms [User: 393.1 ms, System: 36.7 ms]
Range (min … max): 428.2 ms … 434.2 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 3.032 s ± 0.005 s [User: 2.808 s, System: 0.223 s]
Range (min … max): 3.023 s … 3.041 s 50 runs
# after
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 574.7 ms ± 2.8 ms [User: 566.3 ms, System: 8.0 ms]
Range (min … max): 569.2 ms … 580.7 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 394.4 ms ± 0.8 ms [User: 361.8 ms, System: 32.3 ms]
Range (min … max): 392.7 ms … 395.7 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 2.976 s ± 0.005 s [User: 2.757 s, System: 0.218 s]
Range (min … max): 2.966 s … 2.990 s 50 runs
2021-12-21 08:17:31 +00:00
|
|
|
|
StringToken id; // !!! -> Symbol
|
|
|
|
|
StringToken path;
|
|
|
|
|
StringToken uri;
|
2022-01-19 12:39:42 +00:00
|
|
|
|
StringToken str;
|
2013-12-31 23:56:26 +00:00
|
|
|
|
std::vector<nix::AttrName> * attrNames;
|
2021-09-23 02:30:31 +00:00
|
|
|
|
std::vector<std::pair<nix::Pos, nix::Expr *> > * string_parts;
|
2022-01-19 12:39:42 +00:00
|
|
|
|
std::vector<std::pair<nix::Pos, std::variant<nix::Expr *, StringToken> > > * ind_string_parts;
|
2004-01-30 15:21:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
%type <e> start expr expr_function expr_if expr_op
|
2020-03-03 14:32:20 +00:00
|
|
|
|
%type <e> expr_select expr_simple expr_app
|
2010-04-12 18:30:11 +00:00
|
|
|
|
%type <list> expr_list
|
|
|
|
|
%type <attrs> binds
|
2008-08-14 14:00:44 +00:00
|
|
|
|
%type <formals> formals
|
2010-04-12 18:30:11 +00:00
|
|
|
|
%type <formal> formal
|
2013-12-31 23:56:26 +00:00
|
|
|
|
%type <attrNames> attrs attrpath
|
2022-01-19 12:39:42 +00:00
|
|
|
|
%type <string_parts> string_parts_interpolated
|
|
|
|
|
%type <ind_string_parts> ind_string_parts
|
2021-07-29 16:03:07 +00:00
|
|
|
|
%type <e> path_start string_parts string_attr
|
2011-07-13 12:19:57 +00:00
|
|
|
|
%type <id> attr
|
2010-04-12 18:30:11 +00:00
|
|
|
|
%token <id> ID ATTRPATH
|
2022-01-19 12:39:42 +00:00
|
|
|
|
%token <str> STR IND_STR
|
2010-04-12 10:38:18 +00:00
|
|
|
|
%token <n> INT
|
2016-01-04 23:40:40 +00:00
|
|
|
|
%token <nf> FLOAT
|
2021-07-29 16:03:07 +00:00
|
|
|
|
%token <path> PATH HPATH SPATH PATH_END
|
2010-04-12 18:30:11 +00:00
|
|
|
|
%token <uri> URI
|
2011-07-13 12:19:57 +00:00
|
|
|
|
%token IF THEN ELSE ASSERT WITH LET IN REC INHERIT EQ NEQ AND OR IMPL OR_KW
|
2006-05-01 14:01:47 +00:00
|
|
|
|
%token DOLLAR_CURLY /* == ${ */
|
2007-11-30 16:48:45 +00:00
|
|
|
|
%token IND_STRING_OPEN IND_STRING_CLOSE
|
2008-08-14 14:00:44 +00:00
|
|
|
|
%token ELLIPSIS
|
2004-01-30 15:21:42 +00:00
|
|
|
|
|
2018-07-23 07:28:48 +00:00
|
|
|
|
%right IMPL
|
2004-01-30 15:21:42 +00:00
|
|
|
|
%left OR
|
|
|
|
|
%left AND
|
|
|
|
|
%nonassoc EQ NEQ
|
2018-07-21 15:24:51 +00:00
|
|
|
|
%nonassoc '<' '>' LEQ GEQ
|
2004-02-04 16:49:51 +00:00
|
|
|
|
%right UPDATE
|
2013-08-02 15:35:59 +00:00
|
|
|
|
%left NOT
|
2013-08-02 16:03:02 +00:00
|
|
|
|
%left '+' '-'
|
|
|
|
|
%left '*' '/'
|
2005-09-14 11:41:59 +00:00
|
|
|
|
%right CONCAT
|
2004-03-28 21:15:01 +00:00
|
|
|
|
%nonassoc '?'
|
2013-08-02 15:35:59 +00:00
|
|
|
|
%nonassoc NEGATE
|
2004-01-30 15:21:42 +00:00
|
|
|
|
|
|
|
|
|
%%
|
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
start: expr { data->result = $1; };
|
2004-01-30 15:21:42 +00:00
|
|
|
|
|
|
|
|
|
expr: expr_function;
|
|
|
|
|
|
|
|
|
|
expr_function
|
2010-04-12 18:30:11 +00:00
|
|
|
|
: ID ':' expr_function
|
2021-10-06 15:08:08 +00:00
|
|
|
|
{ $$ = new ExprLambda(CUR_POS, data->symbols.create($1), 0, $3); }
|
2010-04-12 18:30:11 +00:00
|
|
|
|
| '{' formals '}' ':' expr_function
|
2022-03-05 13:20:25 +00:00
|
|
|
|
{ $$ = new ExprLambda(CUR_POS, {}, toFormals(*data, $2), $5); }
|
2010-04-12 18:30:11 +00:00
|
|
|
|
| '{' formals '}' '@' ID ':' expr_function
|
2022-01-19 15:49:02 +00:00
|
|
|
|
{
|
|
|
|
|
Symbol arg = data->symbols.create($5);
|
|
|
|
|
$$ = new ExprLambda(CUR_POS, arg, toFormals(*data, $2, CUR_POS, arg), $7);
|
|
|
|
|
}
|
2010-04-12 18:30:11 +00:00
|
|
|
|
| ID '@' '{' formals '}' ':' expr_function
|
2022-01-19 15:49:02 +00:00
|
|
|
|
{
|
|
|
|
|
Symbol arg = data->symbols.create($1);
|
|
|
|
|
$$ = new ExprLambda(CUR_POS, arg, toFormals(*data, $4, CUR_POS, arg), $7);
|
|
|
|
|
}
|
2010-04-12 21:21:24 +00:00
|
|
|
|
| ASSERT expr ';' expr_function
|
|
|
|
|
{ $$ = new ExprAssert(CUR_POS, $2, $4); }
|
2004-10-25 16:54:56 +00:00
|
|
|
|
| WITH expr ';' expr_function
|
2010-04-12 18:30:11 +00:00
|
|
|
|
{ $$ = new ExprWith(CUR_POS, $2, $4); }
|
2006-10-02 15:52:44 +00:00
|
|
|
|
| LET binds IN expr_function
|
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
|
|
|
|
{ if (!$2->dynamicAttrs.empty())
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("dynamic attributes not allowed in let"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = CUR_POS
|
2020-06-15 12:06:58 +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
|
|
|
|
$$ = new ExprLet($2, $4);
|
|
|
|
|
}
|
2004-02-19 13:11:12 +00:00
|
|
|
|
| expr_if
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
expr_if
|
2020-04-09 07:45:15 +00:00
|
|
|
|
: IF expr THEN expr ELSE expr { $$ = new ExprIf(CUR_POS, $2, $4, $6); }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
| expr_op
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
expr_op
|
2013-08-02 15:35:59 +00:00
|
|
|
|
: '!' expr_op %prec NOT { $$ = new ExprOpNot($2); }
|
2020-02-24 00:32:01 +00:00
|
|
|
|
| '-' expr_op %prec NEGATE { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__sub")), {new ExprInt(0), $2}); }
|
2010-04-12 21:21:24 +00:00
|
|
|
|
| expr_op EQ expr_op { $$ = new ExprOpEq($1, $3); }
|
2010-04-12 18:30:11 +00:00
|
|
|
|
| expr_op NEQ expr_op { $$ = new ExprOpNEq($1, $3); }
|
2020-02-24 00:32:01 +00:00
|
|
|
|
| expr_op '<' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__lessThan")), {$1, $3}); }
|
|
|
|
|
| expr_op LEQ expr_op { $$ = new ExprOpNot(new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__lessThan")), {$3, $1})); }
|
|
|
|
|
| expr_op '>' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__lessThan")), {$3, $1}); }
|
|
|
|
|
| expr_op GEQ expr_op { $$ = new ExprOpNot(new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__lessThan")), {$1, $3})); }
|
2014-04-04 20:43:52 +00:00
|
|
|
|
| expr_op AND expr_op { $$ = new ExprOpAnd(CUR_POS, $1, $3); }
|
|
|
|
|
| expr_op OR expr_op { $$ = new ExprOpOr(CUR_POS, $1, $3); }
|
|
|
|
|
| expr_op IMPL expr_op { $$ = new ExprOpImpl(CUR_POS, $1, $3); }
|
|
|
|
|
| expr_op UPDATE expr_op { $$ = new ExprOpUpdate(CUR_POS, $1, $3); }
|
2013-12-31 23:56:26 +00:00
|
|
|
|
| expr_op '?' attrpath { $$ = new ExprOpHasAttr($1, *$3); }
|
2010-04-12 21:21:24 +00:00
|
|
|
|
| expr_op '+' expr_op
|
2022-02-21 15:32:34 +00:00
|
|
|
|
{ $$ = new ExprConcatStrings(CUR_POS, false, new std::vector<std::pair<Pos, Expr *> >({{makeCurPos(@1, data), $1}, {makeCurPos(@3, data), $3}})); }
|
2020-02-24 00:32:01 +00:00
|
|
|
|
| expr_op '-' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__sub")), {$1, $3}); }
|
|
|
|
|
| expr_op '*' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__mul")), {$1, $3}); }
|
|
|
|
|
| expr_op '/' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__div")), {$1, $3}); }
|
2014-04-04 20:43:52 +00:00
|
|
|
|
| expr_op CONCAT expr_op { $$ = new ExprOpConcatLists(CUR_POS, $1, $3); }
|
2020-03-03 14:32:20 +00:00
|
|
|
|
| expr_app
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
expr_app
|
2020-02-24 00:32:01 +00:00
|
|
|
|
: expr_app expr_select {
|
2020-03-03 14:32:20 +00:00
|
|
|
|
if (auto e2 = dynamic_cast<ExprCall *>($1)) {
|
|
|
|
|
e2->args.push_back($2);
|
2020-02-24 00:32:01 +00:00
|
|
|
|
$$ = $1;
|
2020-03-03 14:32:20 +00:00
|
|
|
|
} else
|
|
|
|
|
$$ = new ExprCall(CUR_POS, $1, {$2});
|
2020-02-24 00:32:01 +00:00
|
|
|
|
}
|
2020-03-03 14:32:20 +00:00
|
|
|
|
| expr_select
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
expr_select
|
2011-07-06 12:28:57 +00:00
|
|
|
|
: expr_simple '.' attrpath
|
2014-04-04 20:52:14 +00:00
|
|
|
|
{ $$ = new ExprSelect(CUR_POS, $1, *$3, 0); }
|
2011-07-13 12:19:57 +00:00
|
|
|
|
| expr_simple '.' attrpath OR_KW expr_select
|
2014-04-04 20:52:14 +00:00
|
|
|
|
{ $$ = new ExprSelect(CUR_POS, $1, *$3, $5); }
|
2011-07-13 12:19:57 +00:00
|
|
|
|
| /* Backwards compatibility: because Nixpkgs has a rarely used
|
2016-11-25 23:37:43 +00:00
|
|
|
|
function named ‘or’, allow stuff like ‘map or [...]’. */
|
2011-07-13 12:19:57 +00:00
|
|
|
|
expr_simple OR_KW
|
2020-02-24 00:32:01 +00:00
|
|
|
|
{ $$ = new ExprCall(CUR_POS, $1, {new ExprVar(CUR_POS, data->symbols.create("or"))}); }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
| expr_simple { $$ = $1; }
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
expr_simple
|
2013-11-18 19:14:54 +00:00
|
|
|
|
: ID {
|
2022-01-24 14:18:18 +00:00
|
|
|
|
std::string_view s = "__curPos";
|
2022-01-25 09:49:27 +00:00
|
|
|
|
if ($1.l == s.size() && strncmp($1.p, s.data(), s.size()) == 0)
|
2013-11-18 19:14:54 +00:00
|
|
|
|
$$ = new ExprPos(CUR_POS);
|
|
|
|
|
else
|
|
|
|
|
$$ = new ExprVar(CUR_POS, data->symbols.create($1));
|
|
|
|
|
}
|
2010-04-12 21:21:24 +00:00
|
|
|
|
| INT { $$ = new ExprInt($1); }
|
2016-01-04 23:40:40 +00:00
|
|
|
|
| FLOAT { $$ = new ExprFloat($1); }
|
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
|
|
|
|
| '"' string_parts '"' { $$ = $2; }
|
2007-11-30 16:48:45 +00:00
|
|
|
|
| IND_STRING_OPEN ind_string_parts IND_STRING_CLOSE {
|
2014-04-04 20:19:33 +00:00
|
|
|
|
$$ = stripIndentation(CUR_POS, data->symbols, *$2);
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
2021-07-29 16:03:07 +00:00
|
|
|
|
| path_start PATH_END { $$ = $1; }
|
|
|
|
|
| path_start string_parts_interpolated PATH_END {
|
2021-09-23 02:30:31 +00:00
|
|
|
|
$2->insert($2->begin(), {makeCurPos(@1, data), $1});
|
2021-07-29 16:03:07 +00:00
|
|
|
|
$$ = new ExprConcatStrings(CUR_POS, false, $2);
|
|
|
|
|
}
|
2011-08-06 16:05:24 +00:00
|
|
|
|
| SPATH {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string path($1.p + 1, $1.l - 2);
|
2020-02-24 00:32:01 +00:00
|
|
|
|
$$ = new ExprCall(CUR_POS,
|
|
|
|
|
new ExprVar(data->symbols.create("__findFile")),
|
|
|
|
|
{new ExprVar(data->symbols.create("__nixPath")),
|
2022-01-19 13:31:30 +00:00
|
|
|
|
new ExprString(path)});
|
2011-08-06 16:05:24 +00:00
|
|
|
|
}
|
2019-11-26 18:48:34 +00:00
|
|
|
|
| URI {
|
2021-10-25 13:53:01 +00:00
|
|
|
|
static bool noURLLiterals = settings.isExperimentalFeatureEnabled(Xp::NoUrlLiterals);
|
2019-11-26 18:48:34 +00:00
|
|
|
|
if (noURLLiterals)
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("URL literals are disabled"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = CUR_POS
|
2020-06-15 12:06:58 +00:00
|
|
|
|
});
|
2022-02-25 15:00:00 +00:00
|
|
|
|
$$ = new ExprString(std::string($1));
|
2019-11-26 18:48:34 +00:00
|
|
|
|
}
|
2004-01-30 15:21:42 +00:00
|
|
|
|
| '(' expr ')' { $$ = $2; }
|
2004-02-02 21:39:33 +00:00
|
|
|
|
/* Let expressions `let {..., body = ...}' are just desugared
|
2010-04-12 21:21:24 +00:00
|
|
|
|
into `(rec {..., body = ...}).body'. */
|
2004-02-02 21:39:33 +00:00
|
|
|
|
| LET '{' binds '}'
|
2014-04-04 20:52:14 +00:00
|
|
|
|
{ $3->recursive = true; $$ = new ExprSelect(noPos, $3, data->symbols.create("body")); }
|
2004-02-02 21:39:33 +00:00
|
|
|
|
| REC '{' binds '}'
|
2010-04-12 23:33:23 +00:00
|
|
|
|
{ $3->recursive = true; $$ = $3; }
|
2004-02-02 21:39:33 +00:00
|
|
|
|
| '{' binds '}'
|
2010-04-12 23:33:23 +00:00
|
|
|
|
{ $$ = $2; }
|
2010-04-12 18:30:11 +00:00
|
|
|
|
| '[' expr_list ']' { $$ = $2; }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
|
|
|
|
|
2006-05-01 14:01:47 +00:00
|
|
|
|
string_parts
|
2022-02-25 15:00:00 +00:00
|
|
|
|
: STR { $$ = new ExprString(std::string($1)); }
|
2014-04-04 20:19:33 +00:00
|
|
|
|
| string_parts_interpolated { $$ = new ExprConcatStrings(CUR_POS, true, $1); }
|
2022-01-19 13:31:30 +00:00
|
|
|
|
| { $$ = new ExprString(""); }
|
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
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
string_parts_interpolated
|
2022-01-19 12:39:42 +00:00
|
|
|
|
: string_parts_interpolated STR
|
2022-02-25 15:00:00 +00:00
|
|
|
|
{ $$ = $1; $1->emplace_back(makeCurPos(@2, data), new ExprString(std::string($2))); }
|
2021-09-23 02:30:31 +00:00
|
|
|
|
| string_parts_interpolated DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $3); }
|
2022-02-21 15:32:34 +00:00
|
|
|
|
| DOLLAR_CURLY expr '}' { $$ = new std::vector<std::pair<Pos, Expr *> >; $$->emplace_back(makeCurPos(@1, data), $2); }
|
2015-07-02 16:39:02 +00:00
|
|
|
|
| STR DOLLAR_CURLY expr '}' {
|
2022-02-21 15:32:34 +00:00
|
|
|
|
$$ = new std::vector<std::pair<Pos, Expr *> >;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
$$->emplace_back(makeCurPos(@1, data), new ExprString(std::string($1)));
|
2021-09-23 02:30:31 +00:00
|
|
|
|
$$->emplace_back(makeCurPos(@2, data), $3);
|
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
|
|
|
|
}
|
2006-05-01 14:01:47 +00:00
|
|
|
|
;
|
|
|
|
|
|
2021-07-29 16:03:07 +00:00
|
|
|
|
path_start
|
|
|
|
|
: PATH {
|
don't strdup tokens in the lexer
every stringy token the lexer returns is turned into a Symbol and not
used further, so we don't have to strdup. using a string_view is
sufficient, but due to limitations of the current parser we have to use
a POD type that holds the same information.
gives ~2% on system build, 6% on search, 8% on parsing alone
# before
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 610.6 ms ± 2.4 ms [User: 602.5 ms, System: 7.8 ms]
Range (min … max): 606.6 ms … 617.3 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 430.1 ms ± 1.4 ms [User: 393.1 ms, System: 36.7 ms]
Range (min … max): 428.2 ms … 434.2 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 3.032 s ± 0.005 s [User: 2.808 s, System: 0.223 s]
Range (min … max): 3.023 s … 3.041 s 50 runs
# after
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 574.7 ms ± 2.8 ms [User: 566.3 ms, System: 8.0 ms]
Range (min … max): 569.2 ms … 580.7 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 394.4 ms ± 0.8 ms [User: 361.8 ms, System: 32.3 ms]
Range (min … max): 392.7 ms … 395.7 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 2.976 s ± 0.005 s [User: 2.757 s, System: 0.218 s]
Range (min … max): 2.966 s … 2.990 s 50 runs
2021-12-21 08:17:31 +00:00
|
|
|
|
Path path(absPath({$1.p, $1.l}, data->basePath));
|
2021-07-29 16:03:07 +00:00
|
|
|
|
/* add back in the trailing '/' to the first segment */
|
don't strdup tokens in the lexer
every stringy token the lexer returns is turned into a Symbol and not
used further, so we don't have to strdup. using a string_view is
sufficient, but due to limitations of the current parser we have to use
a POD type that holds the same information.
gives ~2% on system build, 6% on search, 8% on parsing alone
# before
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 610.6 ms ± 2.4 ms [User: 602.5 ms, System: 7.8 ms]
Range (min … max): 606.6 ms … 617.3 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 430.1 ms ± 1.4 ms [User: 393.1 ms, System: 36.7 ms]
Range (min … max): 428.2 ms … 434.2 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 3.032 s ± 0.005 s [User: 2.808 s, System: 0.223 s]
Range (min … max): 3.023 s … 3.041 s 50 runs
# after
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 574.7 ms ± 2.8 ms [User: 566.3 ms, System: 8.0 ms]
Range (min … max): 569.2 ms … 580.7 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 394.4 ms ± 0.8 ms [User: 361.8 ms, System: 32.3 ms]
Range (min … max): 392.7 ms … 395.7 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 2.976 s ± 0.005 s [User: 2.757 s, System: 0.218 s]
Range (min … max): 2.966 s … 2.990 s 50 runs
2021-12-21 08:17:31 +00:00
|
|
|
|
if ($1.p[$1.l-1] == '/' && $1.l > 1)
|
2021-07-29 16:03:07 +00:00
|
|
|
|
path += "/";
|
|
|
|
|
$$ = new ExprPath(path);
|
|
|
|
|
}
|
|
|
|
|
| HPATH {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
Path path(getHome() + std::string($1.p + 1, $1.l - 1));
|
2021-07-29 16:03:07 +00:00
|
|
|
|
$$ = new ExprPath(path);
|
|
|
|
|
}
|
|
|
|
|
;
|
|
|
|
|
|
2007-11-30 16:48:45 +00:00
|
|
|
|
ind_string_parts
|
2021-09-23 02:30:31 +00:00
|
|
|
|
: ind_string_parts IND_STR { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $2); }
|
|
|
|
|
| ind_string_parts DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $3); }
|
2022-02-21 15:32:34 +00:00
|
|
|
|
| { $$ = new std::vector<std::pair<Pos, std::variant<Expr *, StringToken> > >; }
|
2007-11-30 16:48:45 +00:00
|
|
|
|
;
|
|
|
|
|
|
2004-01-30 15:21:42 +00:00
|
|
|
|
binds
|
2013-12-31 22:57:10 +00:00
|
|
|
|
: binds attrpath '=' expr ';' { $$ = $1; addAttr($$, *$2, $4, makeCurPos(@2, data)); }
|
2011-07-13 12:19:57 +00:00
|
|
|
|
| binds INHERIT attrs ';'
|
2010-04-12 18:30:11 +00:00
|
|
|
|
{ $$ = $1;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : *$3) {
|
|
|
|
|
if ($$->attrs.find(i.symbol) != $$->attrs.end())
|
|
|
|
|
dupAttr(i.symbol, makeCurPos(@3, data), $$->attrs[i.symbol].pos);
|
2010-05-07 12:43:57 +00:00
|
|
|
|
Pos pos = makeCurPos(@3, data);
|
2020-02-21 17:31:16 +00:00
|
|
|
|
$$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprVar(CUR_POS, i.symbol), pos, true));
|
2010-04-22 11:02:24 +00:00
|
|
|
|
}
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
2011-07-13 12:19:57 +00:00
|
|
|
|
| binds INHERIT '(' expr ')' attrs ';'
|
2010-04-12 18:30:11 +00:00
|
|
|
|
{ $$ = $1;
|
|
|
|
|
/* !!! Should ensure sharing of the expression in $4. */
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : *$6) {
|
|
|
|
|
if ($$->attrs.find(i.symbol) != $$->attrs.end())
|
|
|
|
|
dupAttr(i.symbol, makeCurPos(@6, data), $$->attrs[i.symbol].pos);
|
2020-02-21 17:31:16 +00:00
|
|
|
|
$$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprSelect(CUR_POS, $4, i.symbol), makeCurPos(@6, data)));
|
2011-07-13 12:19:57 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2021-01-08 21:27:00 +00:00
|
|
|
|
| { $$ = new ExprAttrs(makeCurPos(@0, data)); }
|
2004-02-04 17:23:26 +00:00
|
|
|
|
;
|
|
|
|
|
|
2011-07-13 12:19:57 +00:00
|
|
|
|
attrs
|
2013-12-31 23:56:26 +00:00
|
|
|
|
: attrs attr { $$ = $1; $1->push_back(AttrName(data->symbols.create($2))); }
|
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
|
|
|
|
| attrs string_attr
|
|
|
|
|
{ $$ = $1;
|
2014-10-04 23:04:58 +00:00
|
|
|
|
ExprString * str = dynamic_cast<ExprString *>($2);
|
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
|
|
|
|
if (str) {
|
2022-01-19 13:31:30 +00:00
|
|
|
|
$$->push_back(AttrName(data->symbols.create(str->s)));
|
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
|
|
|
|
delete str;
|
|
|
|
|
} else
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("dynamic attributes not allowed in inherit"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = makeCurPos(@2, data)
|
2020-06-15 12:06:58 +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
|
|
|
|
}
|
2013-12-31 23:56:26 +00:00
|
|
|
|
| { $$ = new AttrPath; }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
|
|
|
|
|
2009-05-15 12:35:23 +00:00
|
|
|
|
attrpath
|
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
|
|
|
|
: attrpath '.' attr { $$ = $1; $1->push_back(AttrName(data->symbols.create($3))); }
|
|
|
|
|
| attrpath '.' string_attr
|
|
|
|
|
{ $$ = $1;
|
2014-10-04 23:04:58 +00:00
|
|
|
|
ExprString * str = dynamic_cast<ExprString *>($3);
|
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
|
|
|
|
if (str) {
|
2022-01-19 13:31:30 +00:00
|
|
|
|
$$->push_back(AttrName(data->symbols.create(str->s)));
|
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
|
|
|
|
delete str;
|
|
|
|
|
} else
|
2014-10-04 23:04:58 +00:00
|
|
|
|
$$->push_back(AttrName($3));
|
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
|
|
|
|
}
|
2022-02-21 15:32:34 +00:00
|
|
|
|
| attr { $$ = new std::vector<AttrName>; $$->push_back(AttrName(data->symbols.create($1))); }
|
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
|
|
|
|
| string_attr
|
2022-02-21 15:32:34 +00:00
|
|
|
|
{ $$ = new std::vector<AttrName>;
|
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
|
|
|
|
ExprString *str = dynamic_cast<ExprString *>($1);
|
|
|
|
|
if (str) {
|
2022-01-19 13:31:30 +00:00
|
|
|
|
$$->push_back(AttrName(data->symbols.create(str->s)));
|
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
|
|
|
|
delete str;
|
|
|
|
|
} else
|
2014-10-04 23:04:58 +00:00
|
|
|
|
$$->push_back(AttrName($1));
|
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
|
|
|
|
}
|
2011-07-13 12:19:57 +00:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
attr
|
|
|
|
|
: ID { $$ = $1; }
|
don't strdup tokens in the lexer
every stringy token the lexer returns is turned into a Symbol and not
used further, so we don't have to strdup. using a string_view is
sufficient, but due to limitations of the current parser we have to use
a POD type that holds the same information.
gives ~2% on system build, 6% on search, 8% on parsing alone
# before
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 610.6 ms ± 2.4 ms [User: 602.5 ms, System: 7.8 ms]
Range (min … max): 606.6 ms … 617.3 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 430.1 ms ± 1.4 ms [User: 393.1 ms, System: 36.7 ms]
Range (min … max): 428.2 ms … 434.2 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 3.032 s ± 0.005 s [User: 2.808 s, System: 0.223 s]
Range (min … max): 3.023 s … 3.041 s 50 runs
# after
Benchmark 1: nix search --offline nixpkgs hello
Time (mean ± σ): 574.7 ms ± 2.8 ms [User: 566.3 ms, System: 8.0 ms]
Range (min … max): 569.2 ms … 580.7 ms 50 runs
Benchmark 2: nix eval -f hackage-packages.nix
Time (mean ± σ): 394.4 ms ± 0.8 ms [User: 361.8 ms, System: 32.3 ms]
Range (min … max): 392.7 ms … 395.7 ms 50 runs
Benchmark 3: nix eval --raw --impure --expr 'with import <nixpkgs/nixos> {}; system'
Time (mean ± σ): 2.976 s ± 0.005 s [User: 2.757 s, System: 0.218 s]
Range (min … max): 2.966 s … 2.990 s 50 runs
2021-12-21 08:17:31 +00:00
|
|
|
|
| OR_KW { $$ = {"or", 2}; }
|
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
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
string_attr
|
|
|
|
|
: '"' string_parts '"' { $$ = $2; }
|
2014-10-04 23:04:58 +00:00
|
|
|
|
| DOLLAR_CURLY expr '}' { $$ = $2; }
|
2009-05-15 12:35:23 +00:00
|
|
|
|
;
|
|
|
|
|
|
2004-01-30 15:21:42 +00:00
|
|
|
|
expr_list
|
2010-04-12 18:30:11 +00:00
|
|
|
|
: expr_list expr_select { $$ = $1; $1->elems.push_back($2); /* !!! dangerous */ }
|
|
|
|
|
| { $$ = new ExprList; }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
formals
|
2010-04-12 18:30:11 +00:00
|
|
|
|
: formal ',' formals
|
2022-01-19 15:49:02 +00:00
|
|
|
|
{ $$ = $3; $$->formals.push_back(*$1); }
|
2008-08-14 14:00:44 +00:00
|
|
|
|
| formal
|
2022-01-19 15:49:02 +00:00
|
|
|
|
{ $$ = new ParserFormals; $$->formals.push_back(*$1); $$->ellipsis = false; }
|
2008-08-14 14:00:44 +00:00
|
|
|
|
|
|
2022-01-19 15:49:02 +00:00
|
|
|
|
{ $$ = new ParserFormals; $$->ellipsis = false; }
|
2008-08-14 14:00:44 +00:00
|
|
|
|
| ELLIPSIS
|
2022-01-19 15:49:02 +00:00
|
|
|
|
{ $$ = new ParserFormals; $$->ellipsis = true; }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
formal
|
2020-04-02 03:03:58 +00:00
|
|
|
|
: ID { $$ = new Formal(CUR_POS, data->symbols.create($1), 0); }
|
|
|
|
|
| ID '?' expr { $$ = new Formal(CUR_POS, data->symbols.create($1), $3); }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2004-01-30 15:21:42 +00:00
|
|
|
|
%%
|
2006-09-04 21:36:15 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
2016-04-29 19:04:40 +00:00
|
|
|
|
#include "eval.hh"
|
2020-04-06 21:57:28 +00:00
|
|
|
|
#include "filetransfer.hh"
|
2020-03-30 14:04:18 +00:00
|
|
|
|
#include "fetchers.hh"
|
2016-04-29 19:04:40 +00:00
|
|
|
|
#include "store-api.hh"
|
2010-04-13 12:25:42 +00:00
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
|
|
|
|
|
namespace nix {
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
|
2021-12-21 12:56:57 +00:00
|
|
|
|
Expr * EvalState::parse(char * text, size_t length, FileOrigin origin,
|
2022-01-21 16:55:51 +00:00
|
|
|
|
const PathView path, const PathView basePath, StaticEnv & staticEnv)
|
2006-09-04 21:36:15 +00:00
|
|
|
|
{
|
|
|
|
|
yyscan_t scanner;
|
2011-08-06 16:05:24 +00:00
|
|
|
|
ParseData data(*this);
|
2020-05-21 04:18:26 +00:00
|
|
|
|
data.origin = origin;
|
|
|
|
|
switch (origin) {
|
2021-01-20 23:27:36 +00:00
|
|
|
|
case foFile:
|
2020-05-21 04:18:26 +00:00
|
|
|
|
data.file = data.symbols.create(path);
|
|
|
|
|
break;
|
|
|
|
|
case foStdin:
|
|
|
|
|
case foString:
|
|
|
|
|
data.file = data.symbols.create(text);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2020-07-02 13:14:40 +00:00
|
|
|
|
assert(false);
|
2020-05-21 04:18:26 +00:00
|
|
|
|
}
|
2006-09-04 21:36:15 +00:00
|
|
|
|
data.basePath = basePath;
|
|
|
|
|
|
|
|
|
|
yylex_init(&scanner);
|
2021-12-21 12:56:57 +00:00
|
|
|
|
yy_scan_buffer(text, length, scanner);
|
2006-09-04 21:36:15 +00:00
|
|
|
|
int res = yyparse(scanner, &data);
|
|
|
|
|
yylex_destroy(scanner);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2021-01-20 23:27:36 +00:00
|
|
|
|
if (res) throw ParseError(data.error.value());
|
2006-09-04 21:36:15 +00:00
|
|
|
|
|
2013-10-08 12:40:51 +00:00
|
|
|
|
data.result->bindVars(staticEnv);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
return data.result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-09-03 10:56:33 +00:00
|
|
|
|
Path resolveExprPath(Path path)
|
2006-09-04 21:36:15 +00:00
|
|
|
|
{
|
|
|
|
|
assert(path[0] == '/');
|
|
|
|
|
|
2019-12-13 13:44:14 +00:00
|
|
|
|
unsigned int followCount = 0, maxFollow = 1024;
|
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
/* If `path' is a symlink, follow it. This is so that relative
|
|
|
|
|
path references work. */
|
|
|
|
|
struct stat st;
|
2007-01-15 14:50:25 +00:00
|
|
|
|
while (true) {
|
2019-12-13 13:44:14 +00:00
|
|
|
|
// Basic cycle/depth limit to avoid infinite loops.
|
|
|
|
|
if (++followCount >= maxFollow)
|
2019-12-15 09:44:53 +00:00
|
|
|
|
throw Error("too many symbolic links encountered while traversing the path '%s'", path);
|
2020-09-23 17:17:28 +00:00
|
|
|
|
st = lstat(path);
|
2007-01-15 14:50:25 +00:00
|
|
|
|
if (!S_ISLNK(st.st_mode)) break;
|
|
|
|
|
path = absPath(readLink(path), dirOf(path));
|
|
|
|
|
}
|
2006-09-04 21:36:15 +00:00
|
|
|
|
|
|
|
|
|
/* If `path' refers to a directory, append `/default.nix'. */
|
|
|
|
|
if (S_ISDIR(st.st_mode))
|
|
|
|
|
path = canonPath(path + "/default.nix");
|
|
|
|
|
|
2013-09-03 10:56:33 +00:00
|
|
|
|
return path;
|
|
|
|
|
}
|
2011-08-06 13:02:55 +00:00
|
|
|
|
|
2013-09-03 10:56:33 +00:00
|
|
|
|
|
|
|
|
|
Expr * EvalState::parseExprFromFile(const Path & path)
|
|
|
|
|
{
|
Add primop ‘scopedImport’
‘scopedImport’ works like ‘import’, except that it takes a set of
attributes to be added to the lexical scope of the expression,
essentially extending or overriding the builtin variables. For
instance, the expression
scopedImport { x = 1; } ./foo.nix
where foo.nix contains ‘x’, will evaluate to 1.
This has a few applications:
* It allows getting rid of function argument specifications in package
expressions. For instance, a package expression like:
{ stdenv, fetchurl, libfoo }:
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
can now we written as just
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
and imported in all-packages.nix as:
bar = scopedImport pkgs ./bar.nix;
So whereas we once had dependencies listed in three places
(buildInputs, the function, and the call site), they now only need
to appear in one place.
* It allows overriding builtin functions. For instance, to trace all
calls to ‘map’:
let
overrides = {
map = f: xs: builtins.trace "map called!" (map f xs);
# Ensure that our override gets propagated by calls to
# import/scopedImport.
import = fn: scopedImport overrides fn;
scopedImport = attrs: fn: scopedImport (overrides // attrs) fn;
# Also update ‘builtins’.
builtins = builtins // overrides;
};
in scopedImport overrides ./bla.nix
* Similarly, it allows extending the set of builtin functions. For
instance, during Nixpkgs/NixOS evaluation, the Nixpkgs library
functions could be added to the default scope.
There is a downside: calls to scopedImport are not memoized, unlike
import. So importing a file multiple times leads to multiple parsings
/ evaluations. It would be possible to construct the AST only once,
but that would require careful handling of variables/environments.
2014-05-26 11:46:11 +00:00
|
|
|
|
return parseExprFromFile(path, staticBaseEnv);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Expr * EvalState::parseExprFromFile(const Path & path, StaticEnv & staticEnv)
|
|
|
|
|
{
|
2021-12-21 12:56:57 +00:00
|
|
|
|
auto buffer = readFile(path);
|
|
|
|
|
// readFile should have left some extra space for terminators
|
|
|
|
|
buffer.append("\0\0", 2);
|
|
|
|
|
return parse(buffer.data(), buffer.size(), foFile, path, dirOf(path), staticEnv);
|
2006-09-04 21:36:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2021-12-21 12:56:57 +00:00
|
|
|
|
Expr * EvalState::parseExprFromString(std::string s, const Path & basePath, StaticEnv & staticEnv)
|
2013-09-02 16:34:04 +00:00
|
|
|
|
{
|
2021-12-21 12:56:57 +00:00
|
|
|
|
s.append("\0\0", 2);
|
|
|
|
|
return parse(s.data(), s.size(), foString, "", basePath, staticEnv);
|
2013-09-02 16:34:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2021-12-21 12:56:57 +00:00
|
|
|
|
Expr * EvalState::parseExprFromString(std::string s, const Path & basePath)
|
2006-09-04 21:36:15 +00:00
|
|
|
|
{
|
2021-12-21 12:56:57 +00:00
|
|
|
|
return parseExprFromString(std::move(s), basePath, staticBaseEnv);
|
2006-09-04 21:36:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-08-06 16:05:24 +00:00
|
|
|
|
|
2017-07-25 13:09:06 +00:00
|
|
|
|
Expr * EvalState::parseStdin()
|
|
|
|
|
{
|
|
|
|
|
//Activity act(*logger, lvlTalkative, format("parsing standard input"));
|
2021-12-21 12:56:57 +00:00
|
|
|
|
auto buffer = drainFD(0);
|
|
|
|
|
// drainFD should have left some extra space for terminators
|
|
|
|
|
buffer.append("\0\0", 2);
|
|
|
|
|
return parse(buffer.data(), buffer.size(), foStdin, "", absPath("."), staticBaseEnv);
|
2017-07-25 13:09:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
void EvalState::addToSearchPath(const std::string & s)
|
2011-08-06 16:05:24 +00:00
|
|
|
|
{
|
2011-08-06 17:48:57 +00:00
|
|
|
|
size_t pos = s.find('=');
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string prefix;
|
2011-08-06 17:48:57 +00:00
|
|
|
|
Path path;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
if (pos == std::string::npos) {
|
2011-08-06 17:48:57 +00:00
|
|
|
|
path = s;
|
|
|
|
|
} else {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
prefix = std::string(s, 0, pos);
|
|
|
|
|
path = std::string(s, pos + 1);
|
2011-08-06 17:48:57 +00:00
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2016-04-14 13:32:24 +00:00
|
|
|
|
searchPath.emplace_back(prefix, path);
|
2011-08-06 16:05:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
Path EvalState::findFile(const std::string_view path)
|
2014-05-26 15:02:22 +00:00
|
|
|
|
{
|
|
|
|
|
return findFile(searchPath, path);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, const Pos & pos)
|
2011-08-06 16:05:24 +00:00
|
|
|
|
{
|
2015-05-05 15:09:42 +00:00
|
|
|
|
for (auto & i : searchPath) {
|
2016-04-14 13:32:24 +00:00
|
|
|
|
std::string suffix;
|
2015-05-05 15:09:42 +00:00
|
|
|
|
if (i.first.empty())
|
2022-01-21 13:44:00 +00:00
|
|
|
|
suffix = concatStrings("/", path);
|
2011-08-06 17:48:57 +00:00
|
|
|
|
else {
|
2016-04-14 13:32:24 +00:00
|
|
|
|
auto s = i.first.size();
|
|
|
|
|
if (path.compare(0, s, i.first) != 0 ||
|
|
|
|
|
(path.size() > s && path[s] != '/'))
|
2011-08-06 17:48:57 +00:00
|
|
|
|
continue;
|
2022-01-21 13:44:00 +00:00
|
|
|
|
suffix = path.size() == s ? "" : concatStrings("/", path.substr(s));
|
2011-08-06 17:48:57 +00:00
|
|
|
|
}
|
2016-04-14 13:32:24 +00:00
|
|
|
|
auto r = resolveSearchPathElem(i);
|
|
|
|
|
if (!r.first) continue;
|
|
|
|
|
Path res = r.second + suffix;
|
2011-08-06 16:05:24 +00:00
|
|
|
|
if (pathExists(res)) return canonPath(res);
|
|
|
|
|
}
|
2020-12-22 13:43:20 +00:00
|
|
|
|
|
|
|
|
|
if (hasPrefix(path, "nix/"))
|
2022-01-21 13:44:00 +00:00
|
|
|
|
return concatStrings(corepkgsPrefix, path.substr(4));
|
2020-12-22 13:43:20 +00:00
|
|
|
|
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ThrownError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(evalSettings.pureEval
|
2020-06-15 14:12:27 +00:00
|
|
|
|
? "cannot look up '<%s>' in pure evaluation mode (use '--impure' to override)"
|
|
|
|
|
: "file '%s' was not found in the Nix search path (add it using $NIX_PATH or -I)",
|
|
|
|
|
path),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2020-06-15 12:06:58 +00:00
|
|
|
|
});
|
2011-08-06 16:05:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-14 13:32:24 +00:00
|
|
|
|
std::pair<bool, std::string> EvalState::resolveSearchPathElem(const SearchPathElem & elem)
|
|
|
|
|
{
|
|
|
|
|
auto i = searchPathResolved.find(elem.second);
|
|
|
|
|
if (i != searchPathResolved.end()) return i->second;
|
|
|
|
|
|
|
|
|
|
std::pair<bool, std::string> res;
|
|
|
|
|
|
|
|
|
|
if (isUri(elem.second)) {
|
|
|
|
|
try {
|
2020-03-30 14:04:18 +00:00
|
|
|
|
res = { true, store->toRealPath(fetchers::downloadTarball(
|
2020-09-29 11:05:19 +00:00
|
|
|
|
store, resolveUri(elem.second), "source", false).first.storePath) };
|
2020-04-08 12:12:22 +00:00
|
|
|
|
} catch (FileTransferError & e) {
|
2020-06-15 12:06:58 +00:00
|
|
|
|
logWarning({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("Nix search path entry '%1%' cannot be downloaded, ignoring", elem.second)
|
2020-05-12 18:19:34 +00:00
|
|
|
|
});
|
2016-04-14 13:32:24 +00:00
|
|
|
|
res = { false, "" };
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
auto path = absPath(elem.second);
|
|
|
|
|
if (pathExists(path))
|
|
|
|
|
res = { true, path };
|
|
|
|
|
else {
|
2020-06-15 12:06:58 +00:00
|
|
|
|
logWarning({
|
2021-10-27 16:14:12 +00:00
|
|
|
|
.msg = hintfmt("Nix search path entry '%1%' does not exist, ignoring", elem.second)
|
2020-05-03 14:01:25 +00:00
|
|
|
|
});
|
2016-04-14 13:32:24 +00:00
|
|
|
|
res = { false, "" };
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-30 11:27:57 +00:00
|
|
|
|
debug(format("resolved search path element '%s' to '%s'") % elem.second % res.second);
|
2016-04-14 13:32:24 +00:00
|
|
|
|
|
|
|
|
|
searchPathResolved[elem.second] = res;
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-09-04 21:36:15 +00:00
|
|
|
|
}
|