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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
use std::{
cell::RefCell,
collections::{BTreeMap, HashMap},
env,
fs::File,
io::{self, Read},
rc::Rc,
time::{SystemTime, UNIX_EPOCH},
};
use crate::{
errors::ErrorKind,
observer::NoOpObserver,
value::{Builtin, CoercionKind, NixAttrs, NixString, Thunk},
vm::VM,
SourceCode, Value,
};
fn impure_builtins() -> Vec<Builtin> {
vec![
Builtin::new("getEnv", &[true], |args: Vec<Value>, vm: &mut VM| {
Ok(env::var(args[0].coerce_to_string(CoercionKind::Weak, vm)?)
.unwrap_or_else(|_| "".into())
.into())
}),
Builtin::new("pathExists", &[true], |args: Vec<Value>, vm: &mut VM| {
Ok(super::coerce_value_to_path(&args[0], vm)?.exists().into())
}),
Builtin::new("readDir", &[true], |args: Vec<Value>, vm: &mut VM| {
let path = super::coerce_value_to_path(&args[0], vm)?;
let mk_err = |err: io::Error| ErrorKind::IO {
path: Some(path.clone()),
error: Rc::new(err),
};
let mut res = BTreeMap::new();
for entry in path.read_dir().map_err(mk_err)? {
let entry = entry.map_err(mk_err)?;
let file_type = entry
.metadata()
.map_err(|err| ErrorKind::IO {
path: Some(entry.path()),
error: Rc::new(err),
})?
.file_type();
let val = if file_type.is_dir() {
"directory"
} else if file_type.is_file() {
"regular"
} else if file_type.is_symlink() {
"symlink"
} else {
"unknown"
};
res.insert(
entry.file_name().to_string_lossy().as_ref().into(),
val.into(),
);
}
Ok(Value::attrs(NixAttrs::from_map(res)))
}),
Builtin::new("readFile", &[true], |args: Vec<Value>, vm: &mut VM| {
let mut buf = String::new();
File::open(&super::coerce_value_to_path(&args[0], vm)?)?.read_to_string(&mut buf)?;
Ok(buf.into())
}),
]
}
/// Return all impure builtins, that is all builtins which may perform I/O
/// outside of the VM and so cannot be used in all contexts (e.g. WASM).
pub(super) fn builtins() -> BTreeMap<NixString, Value> {
let mut map: BTreeMap<NixString, Value> = impure_builtins()
.into_iter()
.map(|b| (b.name().into(), Value::Builtin(b)))
.collect();
// currentTime pins the time at which evaluation was started
{
let seconds = match SystemTime::now().duration_since(UNIX_EPOCH) {
Ok(dur) => dur.as_secs() as i64,
// This case is hit if the system time is *before* epoch.
Err(err) => -(err.duration().as_secs() as i64),
};
map.insert(NixString::from("currentTime"), Value::Integer(seconds));
}
map
}
/// Constructs and inserts the `import` builtin. This builtin is special in that
/// it needs to capture the [crate::SourceCode] structure to correctly track
/// source code locations while invoking a compiler.
// TODO: need to be able to pass through a CompilationObserver, too.
pub fn builtins_import(
globals: Rc<RefCell<HashMap<&'static str, Value>>>,
source: SourceCode,
) -> Builtin {
Builtin::new(
"import",
&[true],
move |mut args: Vec<Value>, vm: &mut VM| {
let mut path = super::coerce_value_to_path(&args.pop().unwrap(), vm)?;
if path.is_dir() {
path.push("default.nix");
}
let contents =
std::fs::read_to_string(&path).map_err(|err| ErrorKind::ReadFileError {
path: path.clone(),
error: Rc::new(err),
})?;
let parsed = rnix::ast::Root::parse(&contents);
let errors = parsed.errors();
let file = source.add_file(path.to_string_lossy().to_string(), contents);
if !errors.is_empty() {
return Err(ErrorKind::ImportParseError {
path,
file,
errors: errors.to_vec(),
});
}
let result = crate::compile(
&parsed.tree().expr().unwrap(),
Some(path.clone()),
file,
globals.clone(),
&mut NoOpObserver::default(),
)
.map_err(|err| ErrorKind::ImportCompilerError {
path: path.clone(),
errors: vec![err],
})?;
if !result.errors.is_empty() {
return Err(ErrorKind::ImportCompilerError {
path,
errors: result.errors,
});
}
for warning in result.warnings {
vm.push_warning(warning);
}
// Compilation succeeded, we can construct a thunk from whatever it spat
// out and return that.
Ok(Value::Thunk(Thunk::new(result.lambda)))
},
)
}
|
