2012-07-18 18:59:03 +00:00
|
|
|
#pragma once
|
2003-10-30 16:11:24 +00:00
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
#include <map>
|
|
|
|
#include <vector>
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
#include "value.hh"
|
2010-04-13 12:25:42 +00:00
|
|
|
#include "symbol-table.hh"
|
2020-05-11 21:52:15 +00:00
|
|
|
#include "error.hh"
|
2022-04-22 08:01:02 +00:00
|
|
|
#include "chunked-vector.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
|
|
|
|
|
|
namespace nix {
|
2003-10-30 16:11:24 +00:00
|
|
|
|
|
|
|
|
2019-11-10 16:14:26 +00:00
|
|
|
MakeError(EvalError, Error);
|
|
|
|
MakeError(ParseError, Error);
|
|
|
|
MakeError(AssertionError, EvalError);
|
|
|
|
MakeError(ThrownError, AssertionError);
|
|
|
|
MakeError(Abort, EvalError);
|
|
|
|
MakeError(TypeError, EvalError);
|
|
|
|
MakeError(UndefinedVarError, Error);
|
2021-02-22 15:13:09 +00:00
|
|
|
MakeError(MissingArgumentError, EvalError);
|
2019-11-10 16:14:26 +00:00
|
|
|
MakeError(RestrictedPathError, Error);
|
2006-07-19 15:36:15 +00:00
|
|
|
|
2022-01-08 18:03:48 +00:00
|
|
|
extern std::function<void(const Error * error, const Env & env, const Expr & expr)> debuggerHook;
|
2006-07-19 15:36:15 +00:00
|
|
|
|
2010-04-14 14:42:32 +00:00
|
|
|
/* Position objects. */
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct Pos
|
|
|
|
{
|
2022-03-05 16:31:50 +00:00
|
|
|
std::string file;
|
2022-03-04 18:31:59 +00:00
|
|
|
FileOrigin origin;
|
2022-01-01 18:24:20 +00:00
|
|
|
uint32_t line;
|
2022-03-04 18:31:59 +00:00
|
|
|
uint32_t column;
|
|
|
|
|
|
|
|
explicit operator bool() const { return line > 0; }
|
|
|
|
};
|
|
|
|
|
|
|
|
class PosIdx {
|
|
|
|
friend class PosTable;
|
|
|
|
|
|
|
|
private:
|
|
|
|
uint32_t id;
|
|
|
|
|
|
|
|
explicit PosIdx(uint32_t id): id(id) {}
|
|
|
|
|
|
|
|
public:
|
|
|
|
PosIdx() : id(0) {}
|
|
|
|
|
|
|
|
explicit operator bool() const { return id > 0; }
|
|
|
|
|
|
|
|
bool operator<(const PosIdx other) const { return id < other.id; }
|
|
|
|
};
|
|
|
|
|
|
|
|
class PosTable
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
class Origin {
|
|
|
|
friend PosTable;
|
|
|
|
private:
|
|
|
|
// must always be invalid by default, add() replaces this with the actual value.
|
|
|
|
// subsequent add() calls use this index as a token to quickly check whether the
|
|
|
|
// current origins.back() can be reused or not.
|
|
|
|
mutable uint32_t idx = std::numeric_limits<uint32_t>::max();
|
|
|
|
|
|
|
|
explicit Origin(uint32_t idx): idx(idx), file{}, origin{} {}
|
|
|
|
|
|
|
|
public:
|
2022-03-05 16:31:50 +00:00
|
|
|
const std::string file;
|
2022-03-04 18:31:59 +00:00
|
|
|
const FileOrigin origin;
|
|
|
|
|
2022-03-05 16:31:50 +00:00
|
|
|
Origin(std::string file, FileOrigin origin): file(std::move(file)), origin(origin) {}
|
2022-03-04 18:31:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct Offset {
|
|
|
|
uint32_t line, column;
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::vector<Origin> origins;
|
|
|
|
ChunkedVector<Offset, 8192> offsets;
|
|
|
|
|
|
|
|
public:
|
|
|
|
PosTable(): offsets(1024)
|
|
|
|
{
|
|
|
|
origins.reserve(1024);
|
|
|
|
}
|
|
|
|
|
|
|
|
PosIdx add(const Origin & origin, uint32_t line, uint32_t column)
|
2014-04-04 19:14:11 +00:00
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
const auto idx = offsets.add({line, column}).second;
|
|
|
|
if (origins.empty() || origins.back().idx != origin.idx) {
|
|
|
|
origin.idx = idx;
|
|
|
|
origins.push_back(origin);
|
|
|
|
}
|
|
|
|
return PosIdx(idx + 1);
|
2014-04-04 19:14:11 +00:00
|
|
|
}
|
2022-02-25 15:00:00 +00:00
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
Pos operator[](PosIdx p) const
|
2012-08-13 03:29:28 +00:00
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
if (p.id == 0 || p.id > offsets.size())
|
|
|
|
return {};
|
|
|
|
const auto idx = p.id - 1;
|
|
|
|
/* we want the last key <= idx, so we'll take prev(first key > idx).
|
|
|
|
this is guaranteed to never rewind origin.begin because the first
|
|
|
|
key is always 0. */
|
|
|
|
const auto pastOrigin = std::upper_bound(
|
|
|
|
origins.begin(), origins.end(), Origin(idx),
|
|
|
|
[] (const auto & a, const auto & b) { return a.idx < b.idx; });
|
|
|
|
const auto origin = *std::prev(pastOrigin);
|
|
|
|
const auto offset = offsets[idx];
|
|
|
|
return {origin.file, origin.origin, offset.line, offset.column};
|
2012-08-13 03:29:28 +00:00
|
|
|
}
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
inline PosIdx noPos = {};
|
2010-05-06 16:46:48 +00:00
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
std::ostream & operator << (std::ostream & str, const Pos & pos);
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct Env;
|
|
|
|
struct Value;
|
2014-01-21 17:29:55 +00:00
|
|
|
class EvalState;
|
2010-04-14 14:42:32 +00:00
|
|
|
struct StaticEnv;
|
|
|
|
|
|
|
|
|
2011-07-06 10:58:17 +00:00
|
|
|
/* An attribute path is a sequence of attribute names. */
|
2013-12-31 23:56:26 +00:00
|
|
|
struct AttrName
|
|
|
|
{
|
|
|
|
Symbol symbol;
|
2014-10-04 23:04:58 +00:00
|
|
|
Expr * expr;
|
2022-04-26 11:23:32 +00:00
|
|
|
AttrName(Symbol s) : symbol(s) {};
|
2014-10-04 23:04:58 +00:00
|
|
|
AttrName(Expr * e) : expr(e) {};
|
2013-12-31 23:56:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef std::vector<AttrName> AttrPath;
|
2011-07-06 10:58:17 +00:00
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath);
|
2011-07-06 10:58:17 +00:00
|
|
|
|
|
|
|
|
2010-04-14 14:42:32 +00:00
|
|
|
/* Abstract syntax of Nix expressions. */
|
2010-04-12 18:30:11 +00:00
|
|
|
|
|
|
|
struct Expr
|
|
|
|
{
|
2014-01-21 17:29:55 +00:00
|
|
|
virtual ~Expr() { };
|
2022-03-05 13:40:24 +00:00
|
|
|
virtual void show(const SymbolTable & symbols, std::ostream & str) const;
|
2022-04-28 18:32:57 +00:00
|
|
|
virtual void bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> & env);
|
2010-04-12 22:03:27 +00:00
|
|
|
virtual void eval(EvalState & state, Env & env, Value & v);
|
2012-01-04 21:24:11 +00:00
|
|
|
virtual Value * maybeThunk(EvalState & state, Env & env);
|
2022-04-22 19:45:39 +00:00
|
|
|
virtual void setName(Symbol name);
|
2022-05-05 10:29:14 +00:00
|
|
|
std::shared_ptr<const StaticEnv> staticEnv;
|
|
|
|
virtual PosIdx getPos() const { return noPos; }
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define COMMON_METHODS \
|
2022-03-05 13:40:24 +00:00
|
|
|
void show(const SymbolTable & symbols, std::ostream & str) const; \
|
2010-04-14 14:42:32 +00:00
|
|
|
void eval(EvalState & state, Env & env, Value & v); \
|
2022-04-28 18:32:57 +00:00
|
|
|
void bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> & env);
|
2010-04-12 18:30:11 +00:00
|
|
|
|
|
|
|
struct ExprInt : Expr
|
|
|
|
{
|
2013-08-19 10:35:03 +00:00
|
|
|
NixInt n;
|
2012-01-07 17:26:33 +00:00
|
|
|
Value v;
|
2022-01-04 17:40:39 +00:00
|
|
|
ExprInt(NixInt n) : n(n) { v.mkInt(n); };
|
2012-01-07 17:26:33 +00:00
|
|
|
Value * maybeThunk(EvalState & state, Env & env);
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2016-01-04 23:40:40 +00:00
|
|
|
struct ExprFloat : Expr
|
|
|
|
{
|
|
|
|
NixFloat nf;
|
|
|
|
Value v;
|
2022-01-04 17:40:39 +00:00
|
|
|
ExprFloat(NixFloat nf) : nf(nf) { v.mkFloat(nf); };
|
2016-01-04 23:40:40 +00:00
|
|
|
Value * maybeThunk(EvalState & state, Env & env);
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2016-01-04 23:40:40 +00:00
|
|
|
};
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct ExprString : Expr
|
|
|
|
{
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string s;
|
2012-01-07 17:26:33 +00:00
|
|
|
Value v;
|
2022-01-19 13:31:30 +00:00
|
|
|
ExprString(std::string s) : s(std::move(s)) { v.mkString(this->s.data()); };
|
2012-01-07 17:26:33 +00:00
|
|
|
Value * maybeThunk(EvalState & state, Env & env);
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ExprPath : Expr
|
|
|
|
{
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string s;
|
2012-01-07 17:26:33 +00:00
|
|
|
Value v;
|
2022-02-25 15:00:00 +00:00
|
|
|
ExprPath(std::string s) : s(std::move(s)) { v.mkPath(this->s.c_str()); };
|
2012-01-07 17:26:33 +00:00
|
|
|
Value * maybeThunk(EvalState & state, Env & env);
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2020-02-24 13:33:01 +00:00
|
|
|
typedef uint32_t Level;
|
|
|
|
typedef uint32_t Displacement;
|
|
|
|
|
2013-10-08 12:24:53 +00:00
|
|
|
struct ExprVar : Expr
|
2010-04-12 18:30:11 +00:00
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2010-04-13 12:25:42 +00:00
|
|
|
Symbol name;
|
2010-04-14 14:42:32 +00:00
|
|
|
|
|
|
|
/* Whether the variable comes from an environment (e.g. a rec, let
|
|
|
|
or function argument) or from a "with". */
|
|
|
|
bool fromWith;
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2010-04-14 14:42:32 +00:00
|
|
|
/* In the former case, the value is obtained by going `level'
|
|
|
|
levels up from the current environment and getting the
|
|
|
|
`displ'th value in that environment. In the latter case, the
|
|
|
|
value is obtained by getting the attribute named `name' from
|
2013-10-24 14:41:04 +00:00
|
|
|
the set stored in the environment that is `level' levels up
|
|
|
|
from the current one.*/
|
2020-02-24 13:33:01 +00:00
|
|
|
Level level;
|
|
|
|
Displacement displ;
|
2010-04-14 15:14:23 +00:00
|
|
|
|
2022-04-26 11:23:32 +00:00
|
|
|
ExprVar(Symbol name) : name(name) { };
|
|
|
|
ExprVar(const PosIdx & pos, Symbol name) : pos(pos), name(name) { };
|
2012-01-04 21:24:11 +00:00
|
|
|
Value * maybeThunk(EvalState & state, Env & env);
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ExprSelect : Expr
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2011-07-13 12:19:57 +00:00
|
|
|
Expr * e, * def;
|
2011-07-06 12:28:57 +00:00
|
|
|
AttrPath attrPath;
|
2022-03-04 18:31:59 +00:00
|
|
|
ExprSelect(const PosIdx & pos, Expr * e, const AttrPath & attrPath, Expr * def) : pos(pos), e(e), def(def), attrPath(attrPath) { };
|
2022-04-26 11:23:32 +00:00
|
|
|
ExprSelect(const PosIdx & pos, Expr * e, Symbol name) : pos(pos), e(e), def(0) { attrPath.push_back(AttrName(name)); };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
struct ExprOpHasAttr : Expr
|
|
|
|
{
|
|
|
|
Expr * e;
|
2011-07-06 10:58:17 +00:00
|
|
|
AttrPath attrPath;
|
|
|
|
ExprOpHasAttr(Expr * e, const AttrPath & attrPath) : e(e), attrPath(attrPath) { };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return e->getPos(); }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 21:21:24 +00:00
|
|
|
};
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct ExprAttrs : Expr
|
|
|
|
{
|
|
|
|
bool recursive;
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2010-10-24 19:52:33 +00:00
|
|
|
struct AttrDef {
|
|
|
|
bool inherited;
|
2013-07-15 21:10:18 +00:00
|
|
|
Expr * e;
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2020-02-24 13:33:01 +00:00
|
|
|
Displacement displ; // displacement
|
2022-03-04 18:31:59 +00:00
|
|
|
AttrDef(Expr * e, const PosIdx & pos, bool inherited=false)
|
2014-10-04 23:04:58 +00:00
|
|
|
: inherited(inherited), e(e), pos(pos) { };
|
2010-10-24 19:52:33 +00:00
|
|
|
AttrDef() { };
|
|
|
|
};
|
|
|
|
typedef std::map<Symbol, AttrDef> AttrDefs;
|
|
|
|
AttrDefs attrs;
|
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
|
|
|
struct DynamicAttrDef {
|
2014-10-04 23:04:58 +00:00
|
|
|
Expr * nameExpr, * valueExpr;
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
|
|
|
DynamicAttrDef(Expr * nameExpr, Expr * valueExpr, const PosIdx & pos)
|
2014-10-04 23:04:58 +00:00
|
|
|
: nameExpr(nameExpr), valueExpr(valueExpr), pos(pos) { };
|
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
|
|
|
};
|
|
|
|
typedef std::vector<DynamicAttrDef> DynamicAttrDefs;
|
|
|
|
DynamicAttrDefs dynamicAttrs;
|
2022-03-04 18:31:59 +00:00
|
|
|
ExprAttrs(const PosIdx &pos) : recursive(false), pos(pos) { };
|
|
|
|
ExprAttrs() : recursive(false) { };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
2004-10-26 22:54:26 +00:00
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct ExprList : Expr
|
|
|
|
{
|
|
|
|
std::vector<Expr *> elems;
|
|
|
|
ExprList() { };
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2022-05-05 10:29:14 +00:00
|
|
|
|
|
|
|
PosIdx getPos() const override
|
|
|
|
{
|
|
|
|
return elems.empty() ? noPos : elems.front()->getPos();
|
|
|
|
}
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
2003-10-30 16:11:24 +00:00
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct Formal
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2010-04-13 12:25:42 +00:00
|
|
|
Symbol name;
|
2010-04-12 18:30:11 +00:00
|
|
|
Expr * def;
|
|
|
|
};
|
2004-08-04 10:59:20 +00:00
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct Formals
|
|
|
|
{
|
2022-01-19 15:49:02 +00:00
|
|
|
typedef std::vector<Formal> Formals_;
|
2010-04-12 18:30:11 +00:00
|
|
|
Formals_ formals;
|
|
|
|
bool ellipsis;
|
2022-01-19 15:49:02 +00:00
|
|
|
|
2022-04-26 11:23:32 +00:00
|
|
|
bool has(Symbol arg) const
|
|
|
|
{
|
2022-01-19 15:49:02 +00:00
|
|
|
auto it = std::lower_bound(formals.begin(), formals.end(), arg,
|
|
|
|
[] (const Formal & f, const Symbol & sym) { return f.name < sym; });
|
|
|
|
return it != formals.end() && it->name == arg;
|
|
|
|
}
|
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
std::vector<Formal> lexicographicOrder(const SymbolTable & symbols) const
|
2022-01-19 15:49:02 +00:00
|
|
|
{
|
|
|
|
std::vector<Formal> result(formals.begin(), formals.end());
|
|
|
|
std::sort(result.begin(), result.end(),
|
2022-03-05 13:40:24 +00:00
|
|
|
[&] (const Formal & a, const Formal & b) {
|
|
|
|
std::string_view sa = symbols[a.name], sb = symbols[b.name];
|
|
|
|
return sa < sb;
|
2022-01-19 15:49:02 +00:00
|
|
|
});
|
|
|
|
return result;
|
|
|
|
}
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
2004-08-04 10:59:20 +00:00
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct ExprLambda : Expr
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2013-05-16 17:08:02 +00:00
|
|
|
Symbol name;
|
2010-04-13 12:25:42 +00:00
|
|
|
Symbol arg;
|
2010-04-12 18:30:11 +00:00
|
|
|
Formals * formals;
|
|
|
|
Expr * body;
|
2022-04-22 19:45:39 +00:00
|
|
|
ExprLambda(PosIdx pos, Symbol arg, Formals * formals, Expr * body)
|
2021-10-06 15:08:08 +00:00
|
|
|
: pos(pos), arg(arg), formals(formals), body(body)
|
2010-04-22 11:02:24 +00:00
|
|
|
{
|
2020-04-29 16:14:32 +00:00
|
|
|
};
|
2022-03-05 13:40:24 +00:00
|
|
|
ExprLambda(PosIdx pos, Formals * formals, Expr * body)
|
|
|
|
: pos(pos), formals(formals), body(body)
|
|
|
|
{
|
|
|
|
}
|
2022-04-22 19:45:39 +00:00
|
|
|
void setName(Symbol name);
|
2022-03-05 13:40:24 +00:00
|
|
|
std::string showNamePos(const EvalState & state) const;
|
2021-10-06 15:08:08 +00:00
|
|
|
inline bool hasFormals() const { return formals != nullptr; }
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
struct ExprCall : Expr
|
|
|
|
{
|
|
|
|
Expr * fun;
|
|
|
|
std::vector<Expr *> args;
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
|
|
|
ExprCall(const PosIdx & pos, Expr * fun, std::vector<Expr *> && args)
|
2020-02-24 00:32:01 +00:00
|
|
|
: fun(fun), args(args), pos(pos)
|
|
|
|
{ }
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2010-04-13 13:42:25 +00:00
|
|
|
struct ExprLet : Expr
|
|
|
|
{
|
|
|
|
ExprAttrs * attrs;
|
|
|
|
Expr * body;
|
|
|
|
ExprLet(ExprAttrs * attrs, Expr * body) : attrs(attrs), body(body) { };
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-13 13:42:25 +00:00
|
|
|
};
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
struct ExprWith : Expr
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2010-04-12 18:30:11 +00:00
|
|
|
Expr * attrs, * body;
|
2018-05-02 11:56:34 +00:00
|
|
|
size_t prevWith;
|
2022-03-04 18:31:59 +00:00
|
|
|
ExprWith(const PosIdx & pos, Expr * attrs, Expr * body) : pos(pos), attrs(attrs), body(body) { };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ExprIf : Expr
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2010-04-12 18:30:11 +00:00
|
|
|
Expr * cond, * then, * else_;
|
2022-03-04 18:31:59 +00:00
|
|
|
ExprIf(const PosIdx & pos, Expr * cond, Expr * then, Expr * else_) : pos(pos), cond(cond), then(then), else_(else_) { };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
struct ExprAssert : Expr
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2010-04-12 21:21:24 +00:00
|
|
|
Expr * cond, * body;
|
2022-03-04 18:31:59 +00:00
|
|
|
ExprAssert(const PosIdx & pos, Expr * cond, Expr * body) : pos(pos), cond(cond), body(body) { };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 21:21:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ExprOpNot : Expr
|
|
|
|
{
|
|
|
|
Expr * e;
|
|
|
|
ExprOpNot(Expr * e) : e(e) { };
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 21:21:24 +00:00
|
|
|
};
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
#define MakeBinOp(name, s) \
|
2018-03-09 03:16:33 +00:00
|
|
|
struct name : Expr \
|
2010-04-12 18:30:11 +00:00
|
|
|
{ \
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos; \
|
2010-04-12 18:30:11 +00:00
|
|
|
Expr * e1, * e2; \
|
2018-03-09 03:16:33 +00:00
|
|
|
name(Expr * e1, Expr * e2) : e1(e1), e2(e2) { }; \
|
2022-03-04 18:31:59 +00:00
|
|
|
name(const PosIdx & pos, Expr * e1, Expr * e2) : pos(pos), e1(e1), e2(e2) { }; \
|
2022-03-05 13:40:24 +00:00
|
|
|
void show(const SymbolTable & symbols, std::ostream & str) const \
|
2010-04-12 18:30:11 +00:00
|
|
|
{ \
|
2022-03-05 13:40:24 +00:00
|
|
|
str << "("; e1->show(symbols, str); str << " " s " "; e2->show(symbols, str); str << ")"; \
|
2010-04-12 18:30:11 +00:00
|
|
|
} \
|
2022-04-28 18:32:57 +00:00
|
|
|
void bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> & env) \
|
2010-04-14 14:42:32 +00:00
|
|
|
{ \
|
2022-03-05 13:40:24 +00:00
|
|
|
e1->bindVars(es, env); e2->bindVars(es, env); \
|
2010-04-14 14:42:32 +00:00
|
|
|
} \
|
2010-04-12 18:30:11 +00:00
|
|
|
void eval(EvalState & state, Env & env, Value & v); \
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; } \
|
2010-04-12 18:30:11 +00:00
|
|
|
};
|
|
|
|
|
2018-03-09 03:16:33 +00:00
|
|
|
MakeBinOp(ExprOpEq, "==")
|
|
|
|
MakeBinOp(ExprOpNEq, "!=")
|
|
|
|
MakeBinOp(ExprOpAnd, "&&")
|
|
|
|
MakeBinOp(ExprOpOr, "||")
|
|
|
|
MakeBinOp(ExprOpImpl, "->")
|
|
|
|
MakeBinOp(ExprOpUpdate, "//")
|
|
|
|
MakeBinOp(ExprOpConcatLists, "++")
|
2010-04-12 18:30:11 +00:00
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
struct ExprConcatStrings : Expr
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
2013-03-08 00:24:59 +00:00
|
|
|
bool forceString;
|
2022-03-04 18:31:59 +00:00
|
|
|
std::vector<std::pair<PosIdx, Expr *> > * es;
|
|
|
|
ExprConcatStrings(const PosIdx & pos, bool forceString, std::vector<std::pair<PosIdx, Expr *> > * es)
|
2014-04-04 20:19:33 +00:00
|
|
|
: pos(pos), forceString(forceString), es(es) { };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2010-04-12 21:21:24 +00:00
|
|
|
};
|
2004-04-05 22:27:41 +00:00
|
|
|
|
2013-11-18 19:14:54 +00:00
|
|
|
struct ExprPos : Expr
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
PosIdx pos;
|
|
|
|
ExprPos(const PosIdx & pos) : pos(pos) { };
|
2022-05-05 10:29:14 +00:00
|
|
|
PosIdx getPos() const override { return pos; }
|
2021-12-28 01:29:55 +00:00
|
|
|
COMMON_METHODS
|
2013-11-18 19:14:54 +00:00
|
|
|
};
|
|
|
|
|
2010-04-08 11:41:19 +00:00
|
|
|
|
2010-04-14 14:42:32 +00:00
|
|
|
/* Static environments are used to map variable names onto (level,
|
|
|
|
displacement) pairs used to obtain the value of the variable at
|
|
|
|
runtime. */
|
|
|
|
struct StaticEnv
|
|
|
|
{
|
|
|
|
bool isWith;
|
|
|
|
const StaticEnv * up;
|
2020-02-21 17:31:16 +00:00
|
|
|
|
|
|
|
// Note: these must be in sorted order.
|
2020-02-24 13:33:01 +00:00
|
|
|
typedef std::vector<std::pair<Symbol, Displacement>> Vars;
|
2010-04-14 14:42:32 +00:00
|
|
|
Vars vars;
|
2020-02-21 17:31:16 +00:00
|
|
|
|
|
|
|
StaticEnv(bool isWith, const StaticEnv * up, size_t expectedSize = 0) : isWith(isWith), up(up) {
|
|
|
|
vars.reserve(expectedSize);
|
|
|
|
};
|
|
|
|
|
|
|
|
void sort()
|
|
|
|
{
|
2022-02-04 06:36:56 +00:00
|
|
|
std::stable_sort(vars.begin(), vars.end(),
|
2020-02-21 17:31:16 +00:00
|
|
|
[](const Vars::value_type & a, const Vars::value_type & b) { return a.first < b.first; });
|
|
|
|
}
|
|
|
|
|
2021-12-27 12:18:55 +00:00
|
|
|
void deduplicate()
|
|
|
|
{
|
2022-02-04 06:36:56 +00:00
|
|
|
auto it = vars.begin(), jt = it, end = vars.end();
|
|
|
|
while (jt != end) {
|
|
|
|
*it = *jt++;
|
|
|
|
while (jt != end && it->first == jt->first) *it = *jt++;
|
|
|
|
it++;
|
|
|
|
}
|
|
|
|
vars.erase(it, end);
|
2021-12-27 12:18:55 +00:00
|
|
|
}
|
|
|
|
|
2022-04-26 11:23:32 +00:00
|
|
|
Vars::const_iterator find(Symbol name) const
|
2020-02-21 17:31:16 +00:00
|
|
|
{
|
|
|
|
Vars::value_type key(name, 0);
|
|
|
|
auto i = std::lower_bound(vars.begin(), vars.end(), key);
|
|
|
|
if (i != vars.end() && i->first == name) return i;
|
|
|
|
return vars.end();
|
|
|
|
}
|
2010-04-14 14:42:32 +00:00
|
|
|
};
|
|
|
|
|
2006-10-16 15:55:34 +00:00
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
}
|