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
|
|
|
|
|
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
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
// Helper to prevent an expensive dynamic_cast call in expr_app.
|
|
|
|
|
struct App
|
|
|
|
|
{
|
|
|
|
|
Expr * e;
|
|
|
|
|
bool isCall;
|
|
|
|
|
};
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-22 11:02:24 +00:00
|
|
|
|
static void addFormal(const Pos & pos, Formals * formals, const Formal & formal)
|
2009-05-14 14:29:45 +00:00
|
|
|
|
{
|
2019-10-09 13:51:52 +00:00
|
|
|
|
if (!formals->argNames.insert(formal.name).second)
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw ParseError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("duplicate formal function argument '%1%'",
|
2020-06-15 12:06:58 +00:00
|
|
|
|
formal.name),
|
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
|
|
|
|
formals->formals.push_front(formal);
|
2009-05-14 14:29:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-04-04 20:19:33 +00:00
|
|
|
|
static Expr * stripIndentation(const Pos & pos, SymbolTable & symbols, vector<Expr *> & es)
|
2007-11-30 16:48:45 +00:00
|
|
|
|
{
|
2010-10-23 21:11:59 +00:00
|
|
|
|
if (es.empty()) return new ExprString(symbols.create(""));
|
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;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : es) {
|
|
|
|
|
ExprIndStr * e = dynamic_cast<ExprIndStr *>(i);
|
2010-04-12 22:03:27 +00:00
|
|
|
|
if (!e) {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
/* Anti-quotations end the current start-of-line whitespace. */
|
|
|
|
|
if (atStartOfLine) {
|
|
|
|
|
atStartOfLine = false;
|
|
|
|
|
if (curIndent < minIndent) minIndent = curIndent;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2018-05-02 11:56:34 +00:00
|
|
|
|
for (size_t j = 0; j < e->s.size(); ++j) {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (atStartOfLine) {
|
2010-04-12 22:03:27 +00:00
|
|
|
|
if (e->s[j] == ' ')
|
2007-11-30 16:48:45 +00:00
|
|
|
|
curIndent++;
|
2010-04-12 22:03:27 +00:00
|
|
|
|
else if (e->s[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;
|
|
|
|
|
}
|
2010-04-12 22:03:27 +00:00
|
|
|
|
} else if (e->s[j] == '\n') {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
atStartOfLine = true;
|
|
|
|
|
curIndent = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Strip spaces from each line. */
|
2010-04-12 22:03:27 +00:00
|
|
|
|
vector<Expr *> * es2 = new vector<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();
|
2010-04-12 22:03:27 +00:00
|
|
|
|
for (vector<Expr *>::iterator i = es.begin(); i != es.end(); ++i, --n) {
|
|
|
|
|
ExprIndStr * e = dynamic_cast<ExprIndStr *>(*i);
|
|
|
|
|
if (!e) {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
atStartOfLine = false;
|
|
|
|
|
curDropped = 0;
|
2010-04-12 22:03:27 +00:00
|
|
|
|
es2->push_back(*i);
|
2007-11-30 16:48:45 +00:00
|
|
|
|
continue;
|
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2007-11-30 16:48:45 +00:00
|
|
|
|
string s2;
|
2018-05-02 11:56:34 +00:00
|
|
|
|
for (size_t j = 0; j < e->s.size(); ++j) {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (atStartOfLine) {
|
2010-04-12 22:03:27 +00:00
|
|
|
|
if (e->s[j] == ' ') {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (curDropped++ >= minIndent)
|
2010-04-12 22:03:27 +00:00
|
|
|
|
s2 += e->s[j];
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
2010-04-12 22:03:27 +00:00
|
|
|
|
else if (e->s[j] == '\n') {
|
2007-11-30 16:48:45 +00:00
|
|
|
|
curDropped = 0;
|
2010-04-12 22:03:27 +00:00
|
|
|
|
s2 += e->s[j];
|
2007-11-30 16:48:45 +00:00
|
|
|
|
} else {
|
|
|
|
|
atStartOfLine = false;
|
|
|
|
|
curDropped = 0;
|
2010-04-12 22:03:27 +00:00
|
|
|
|
s2 += e->s[j];
|
2007-11-30 16:48:45 +00:00
|
|
|
|
}
|
|
|
|
|
} else {
|
2010-04-12 22:03:27 +00:00
|
|
|
|
s2 += e->s[j];
|
|
|
|
|
if (e->s[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) {
|
2009-04-16 12:03:17 +00:00
|
|
|
|
string::size_type p = s2.find_last_of('\n');
|
2007-11-30 16:48:45 +00:00
|
|
|
|
if (p != string::npos && s2.find_first_not_of(' ', p + 1) == string::npos)
|
|
|
|
|
s2 = string(s2, 0, p + 1);
|
|
|
|
|
}
|
2010-04-12 22:03:27 +00:00
|
|
|
|
|
2010-10-23 21:11:59 +00:00
|
|
|
|
es2->push_back(new ExprString(symbols.create(s2)));
|
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. */
|
2014-04-04 20:19:33 +00:00
|
|
|
|
return es2->size() == 1 && dynamic_cast<ExprString *>((*es2)[0]) ? (*es2)[0] : 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;
|
|
|
|
|
nix::Formals * formals;
|
|
|
|
|
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;
|
2014-01-21 17:29:55 +00:00
|
|
|
|
const char * id; // !!! -> Symbol
|
2010-04-12 18:30:11 +00:00
|
|
|
|
char * path;
|
|
|
|
|
char * uri;
|
2013-12-31 23:56:26 +00:00
|
|
|
|
std::vector<nix::AttrName> * attrNames;
|
2010-04-12 21:21:24 +00:00
|
|
|
|
std::vector<nix::Expr *> * string_parts;
|
2020-02-24 00:32:01 +00:00
|
|
|
|
nix::App app; // bool == whether this is an ExprCall
|
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-02-24 00:32:01 +00:00
|
|
|
|
%type <e> expr_select expr_simple
|
|
|
|
|
%type <app> 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
|
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
|
|
|
|
%type <string_parts> string_parts_interpolated 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
|
2010-04-12 21:21:24 +00:00
|
|
|
|
%token <e> 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
|
2021-10-06 15:08:08 +00:00
|
|
|
|
{ $$ = new ExprLambda(CUR_POS, data->symbols.create(""), $2, $5); }
|
2010-04-12 18:30:11 +00:00
|
|
|
|
| '{' formals '}' '@' ID ':' expr_function
|
2021-10-06 15:08:08 +00:00
|
|
|
|
{ $$ = new ExprLambda(CUR_POS, data->symbols.create($5), $2, $7); }
|
2010-04-12 18:30:11 +00:00
|
|
|
|
| ID '@' '{' formals '}' ':' expr_function
|
2021-10-06 15:08:08 +00:00
|
|
|
|
{ $$ = new ExprLambda(CUR_POS, data->symbols.create($1), $4, $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
|
2014-10-04 23:04:58 +00:00
|
|
|
|
{ $$ = new ExprConcatStrings(CUR_POS, false, new vector<Expr *>({$1, $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-02-24 00:32:01 +00:00
|
|
|
|
| expr_app { $$ = $1.e; }
|
2004-01-30 15:21:42 +00:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
expr_app
|
2020-02-24 00:32:01 +00:00
|
|
|
|
: expr_app expr_select {
|
|
|
|
|
if ($1.isCall) {
|
|
|
|
|
((ExprCall *) $1.e)->args.push_back($2);
|
|
|
|
|
$$ = $1;
|
|
|
|
|
} else {
|
|
|
|
|
$$.e = new ExprCall(CUR_POS, $1.e, {$2});
|
|
|
|
|
$$.isCall = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
| expr_select { $$.e = $1; $$.isCall = false; }
|
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 {
|
|
|
|
|
if (strcmp($1, "__curPos") == 0)
|
|
|
|
|
$$ = 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 {
|
|
|
|
|
$2->insert($2->begin(), $1);
|
|
|
|
|
$$ = new ExprConcatStrings(CUR_POS, false, $2);
|
|
|
|
|
}
|
2011-08-06 16:05:24 +00:00
|
|
|
|
| SPATH {
|
|
|
|
|
string path($1 + 1, strlen($1) - 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")),
|
|
|
|
|
new ExprString(data->symbols.create(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
|
|
|
|
});
|
2019-11-26 18:48:34 +00:00
|
|
|
|
$$ = new ExprString(data->symbols.create($1));
|
|
|
|
|
}
|
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
|
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
|
|
|
|
: STR
|
2014-04-04 20:19:33 +00:00
|
|
|
|
| string_parts_interpolated { $$ = new ExprConcatStrings(CUR_POS, true, $1); }
|
2014-01-21 14:34:04 +00:00
|
|
|
|
| { $$ = new ExprString(data->symbols.create("")); }
|
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
|
|
|
|
|
: string_parts_interpolated STR { $$ = $1; $1->push_back($2); }
|
2015-07-02 16:39:02 +00:00
|
|
|
|
| string_parts_interpolated DOLLAR_CURLY expr '}' { $$ = $1; $1->push_back($3); }
|
|
|
|
|
| DOLLAR_CURLY expr '}' { $$ = new vector<Expr *>; $$->push_back($2); }
|
|
|
|
|
| STR DOLLAR_CURLY expr '}' {
|
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 vector<Expr *>;
|
|
|
|
|
$$->push_back($1);
|
|
|
|
|
$$->push_back($3);
|
|
|
|
|
}
|
2006-05-01 14:01:47 +00:00
|
|
|
|
;
|
|
|
|
|
|
2021-07-29 16:03:07 +00:00
|
|
|
|
path_start
|
|
|
|
|
: PATH {
|
|
|
|
|
Path path(absPath($1, data->basePath));
|
|
|
|
|
/* add back in the trailing '/' to the first segment */
|
2021-08-31 12:21:42 +00:00
|
|
|
|
if ($1[strlen($1)-1] == '/' && strlen($1) > 1)
|
2021-07-29 16:03:07 +00:00
|
|
|
|
path += "/";
|
|
|
|
|
$$ = new ExprPath(path);
|
|
|
|
|
}
|
|
|
|
|
| HPATH {
|
|
|
|
|
Path path(getHome() + string($1 + 1));
|
|
|
|
|
$$ = new ExprPath(path);
|
|
|
|
|
}
|
|
|
|
|
;
|
|
|
|
|
|
2007-11-30 16:48:45 +00:00
|
|
|
|
ind_string_parts
|
2010-04-12 22:03:27 +00:00
|
|
|
|
: ind_string_parts IND_STR { $$ = $1; $1->push_back($2); }
|
2015-07-02 16:39:02 +00:00
|
|
|
|
| ind_string_parts DOLLAR_CURLY expr '}' { $$ = $1; $1->push_back($3); }
|
2010-04-12 22:03:27 +00:00
|
|
|
|
| { $$ = new vector<Expr *>; }
|
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) {
|
2013-12-31 23:56:26 +00:00
|
|
|
|
$$->push_back(AttrName(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) {
|
|
|
|
|
$$->push_back(AttrName(str->s));
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
| attr { $$ = new vector<AttrName>; $$->push_back(AttrName(data->symbols.create($1))); }
|
|
|
|
|
| string_attr
|
|
|
|
|
{ $$ = new vector<AttrName>;
|
|
|
|
|
ExprString *str = dynamic_cast<ExprString *>($1);
|
|
|
|
|
if (str) {
|
|
|
|
|
$$->push_back(AttrName(str->s));
|
|
|
|
|
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; }
|
|
|
|
|
| OR_KW { $$ = "or"; }
|
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
|
2010-04-22 11:02:24 +00:00
|
|
|
|
{ $$ = $3; addFormal(CUR_POS, $$, *$1); }
|
2008-08-14 14:00:44 +00:00
|
|
|
|
| formal
|
2010-04-22 11:02:24 +00:00
|
|
|
|
{ $$ = new Formals; addFormal(CUR_POS, $$, *$1); $$->ellipsis = false; }
|
2008-08-14 14:00:44 +00:00
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
{ $$ = new Formals; $$->ellipsis = false; }
|
2008-08-14 14:00:44 +00:00
|
|
|
|
| ELLIPSIS
|
2010-04-12 18:30:11 +00:00
|
|
|
|
{ $$ = new Formals; $$->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
|
|
|
|
|
2020-05-21 04:18:26 +00:00
|
|
|
|
Expr * EvalState::parse(const char * text, FileOrigin origin,
|
2013-09-02 16:34:04 +00:00
|
|
|
|
const Path & path, const Path & 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);
|
|
|
|
|
yy_scan_string(text, scanner);
|
|
|
|
|
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)
|
|
|
|
|
{
|
2020-05-21 04:18:26 +00:00
|
|
|
|
return parse(readFile(path).c_str(), foFile, path, dirOf(path), staticEnv);
|
2006-09-04 21:36:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2020-03-11 15:36:36 +00:00
|
|
|
|
Expr * EvalState::parseExprFromString(std::string_view s, const Path & basePath, StaticEnv & staticEnv)
|
2013-09-02 16:34:04 +00:00
|
|
|
|
{
|
2020-05-21 04:18:26 +00:00
|
|
|
|
return parse(s.data(), foString, "", basePath, staticEnv);
|
2013-09-02 16:34:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2020-03-11 15:36:36 +00:00
|
|
|
|
Expr * EvalState::parseExprFromString(std::string_view s, const Path & basePath)
|
2006-09-04 21:36:15 +00:00
|
|
|
|
{
|
2013-09-02 16:34:04 +00:00
|
|
|
|
return parseExprFromString(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"));
|
2020-05-21 04:18:26 +00:00
|
|
|
|
return parse(drainFD(0).data(), foStdin, "", absPath("."), staticBaseEnv);
|
2017-07-25 13:09:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-04-14 13:32:24 +00:00
|
|
|
|
void EvalState::addToSearchPath(const string & s)
|
2011-08-06 16:05:24 +00:00
|
|
|
|
{
|
2011-08-06 17:48:57 +00:00
|
|
|
|
size_t pos = s.find('=');
|
|
|
|
|
string prefix;
|
|
|
|
|
Path path;
|
|
|
|
|
if (pos == string::npos) {
|
|
|
|
|
path = s;
|
|
|
|
|
} else {
|
|
|
|
|
prefix = string(s, 0, pos);
|
|
|
|
|
path = string(s, pos + 1);
|
|
|
|
|
}
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Path EvalState::findFile(const string & path)
|
2014-05-26 15:02:22 +00:00
|
|
|
|
{
|
|
|
|
|
return findFile(searchPath, path);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-01-07 12:43:55 +00:00
|
|
|
|
Path EvalState::findFile(SearchPath & searchPath, const string & 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())
|
2016-04-14 13:32:24 +00:00
|
|
|
|
suffix = "/" + 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;
|
2016-04-14 13:32:24 +00:00
|
|
|
|
suffix = path.size() == s ? "" : "/" + string(path, 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/"))
|
|
|
|
|
return corepkgsPrefix + path.substr(4);
|
|
|
|
|
|
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
|
|
|
|
}
|