about summary refs log tree commit diff
path: root/src/libexpr/nixexpr.hh
blob: dabbaa323710372de3374ed2a60c411b7c2b8788 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#ifndef __NIXEXPR_H
#define __NIXEXPR_H

#include <map>

#include "aterm-map.hh"
#include "types.hh"


namespace nix {


MakeError(EvalError, Error)
MakeError(AssertionError, EvalError)
MakeError(ThrownError, AssertionError)
MakeError(Abort, EvalError)
MakeError(TypeError, EvalError)


/* Nix expressions are represented as ATerms.  The maximal sharing
   property of the ATerm library allows us to implement caching of
   normals forms efficiently. */
typedef ATerm Expr;

typedef ATerm DefaultValue;
typedef ATerm ValidValues;

typedef ATerm Pos;


/* A STL vector of ATerms.  Should be used with great care since it's
   stored on the heap, and the elements are therefore not roots to the
   ATerm garbage collector. */
typedef vector<ATerm> ATermVector;


/* A substitution is a linked list of ATermMaps that map names to
   identifiers.  We use a list of ATermMaps rather than a single to
   make it easy to grow or shrink a substitution when entering a
   scope. */
struct Substitution
{
    ATermMap * map;
    const Substitution * prev;

    Substitution(const Substitution * prev, ATermMap * map)
    {
        this->prev = prev;
        this->map = map;
    }
    
    Expr lookup(Expr name) const
    {
        Expr x;
        for (const Substitution * s(this); s; s = s->prev)
            if ((x = s->map->get(name))) return x;
        return 0;
    }
};


/* Show a position. */
string showPos(ATerm pos);

/* Generic bottomup traversal over ATerms.  The traversal first
   recursively descends into subterms, and then applies the given term
   function to the resulting term. */
struct TermFun
{
    virtual ~TermFun() { }
    virtual ATerm operator () (ATerm e) = 0;
};
ATerm bottomupRewrite(TermFun & f, ATerm e);


/* Query all attributes in an attribute set expression.  The
   expression must be in normal form. */
void queryAllAttrs(Expr e, ATermMap & attrs, bool withPos = false);

/* Query a specific attribute from an attribute set expression.  The
   expression must be in normal form. */
Expr queryAttr(Expr e, const string & name);
Expr queryAttr(Expr e, const string & name, ATerm & pos);

/* Create an attribute set expression from an Attrs value. */
Expr makeAttrs(const ATermMap & attrs);


/* Perform a set of substitutions on an expression. */
Expr substitute(const Substitution & subs, Expr e);


/* Check whether all variables are defined in the given expression.
   Throw an exception if this isn't the case. */
void checkVarDefs(const ATermMap & def, Expr e);


/* Canonicalise a Nix expression by sorting attributes and removing
   location information. */
Expr canonicaliseExpr(Expr e);


/* Create an expression representing a boolean. */
Expr makeBool(bool b);


/* Manipulation of Str() nodes.  Note: matchStr() does not clear
   context!  */
bool matchStr(Expr e, string & s, PathSet & context);

Expr makeStr(const string & s, const PathSet & context = PathSet());


/* Showing types, values. */
string showType(Expr e);

string showValue(Expr e);

 
}


#endif /* !__NIXEXPR_H */