2011-03-21 19:21:35 -05:00
|
|
|
import option.none;
|
|
|
|
import option.some;
|
2011-04-06 19:56:44 -05:00
|
|
|
import util.orb;
|
2011-03-21 19:21:35 -05:00
|
|
|
|
2011-03-24 19:21:09 -05:00
|
|
|
type vbuf = rustrt.vbuf;
|
2010-06-23 23:03:09 -05:00
|
|
|
|
2010-11-09 17:35:40 -06:00
|
|
|
type operator2[T,U,V] = fn(&T, &U) -> V;
|
|
|
|
|
2010-06-23 23:03:09 -05:00
|
|
|
native "rust" mod rustrt {
|
2010-09-22 17:44:13 -05:00
|
|
|
type vbuf;
|
2010-08-19 19:37:22 -05:00
|
|
|
|
2010-09-22 17:44:13 -05:00
|
|
|
fn vec_buf[T](vec[T] v, uint offset) -> vbuf;
|
2010-08-19 19:37:22 -05:00
|
|
|
|
2010-09-22 17:44:13 -05:00
|
|
|
fn vec_len[T](vec[T] v) -> uint;
|
|
|
|
/**
|
|
|
|
* Sometimes we modify the vec internal data via vec_buf and need to
|
|
|
|
* update the vec's fill length accordingly.
|
|
|
|
*/
|
|
|
|
fn vec_len_set[T](vec[T] v, uint n);
|
2010-08-19 19:37:22 -05:00
|
|
|
|
2010-09-22 17:44:13 -05:00
|
|
|
/**
|
|
|
|
* The T in vec_alloc[T, U] is the type of the vec to allocate. The
|
|
|
|
* U is the type of an element in the vec. So to allocate a vec[U] we
|
|
|
|
* want to invoke this as vec_alloc[vec[U], U].
|
|
|
|
*/
|
|
|
|
fn vec_alloc[T, U](uint n_elts) -> vec[U];
|
2011-03-18 15:53:49 -05:00
|
|
|
fn vec_alloc_mut[T, U](uint n_elts) -> vec[mutable U];
|
2010-08-19 19:37:22 -05:00
|
|
|
|
2010-09-22 17:44:13 -05:00
|
|
|
fn refcount[T](vec[T] v) -> uint;
|
2010-08-19 19:37:22 -05:00
|
|
|
|
2010-09-22 17:44:13 -05:00
|
|
|
fn vec_print_debug_info[T](vec[T] v);
|
2011-03-24 19:21:09 -05:00
|
|
|
|
|
|
|
fn vec_from_vbuf[T](vbuf v, uint n_elts) -> vec[T];
|
2010-06-23 23:03:09 -05:00
|
|
|
}
|
|
|
|
|
2010-07-05 16:42:12 -05:00
|
|
|
fn alloc[T](uint n_elts) -> vec[T] {
|
2010-09-22 17:44:13 -05:00
|
|
|
ret rustrt.vec_alloc[vec[T], T](n_elts);
|
2010-06-23 23:03:09 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 15:53:49 -05:00
|
|
|
fn alloc_mut[T](uint n_elts) -> vec[mutable T] {
|
|
|
|
ret rustrt.vec_alloc_mut[vec[mutable T], T](n_elts);
|
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn refcount[T](vec[mutable? T] v) -> uint {
|
2010-11-09 16:15:07 -06:00
|
|
|
auto r = rustrt.refcount[T](v);
|
|
|
|
if (r == dbg.const_refcount) {
|
|
|
|
ret r;
|
|
|
|
} else {
|
|
|
|
// -1 because calling this function incremented the refcount.
|
|
|
|
ret r - 1u;
|
|
|
|
}
|
2010-09-03 18:25:56 -05:00
|
|
|
}
|
|
|
|
|
2011-04-19 15:35:49 -05:00
|
|
|
fn vec_from_vbuf[T](vbuf v, uint n_elts) -> vec[T] {
|
2011-03-24 19:21:09 -05:00
|
|
|
ret rustrt.vec_from_vbuf[T](v, n_elts);
|
|
|
|
}
|
|
|
|
|
2011-04-15 19:44:52 -05:00
|
|
|
// FIXME: Remove me; this is a botch to get around rustboot's bad typechecker.
|
|
|
|
fn empty[T]() -> vec[T] {
|
|
|
|
ret alloc[T](0u);
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: Remove me; this is a botch to get around rustboot's bad typechecker.
|
|
|
|
fn empty_mut[T]() -> vec[mutable T] {
|
|
|
|
ret alloc_mut[T](0u);
|
|
|
|
}
|
|
|
|
|
2010-07-05 16:42:12 -05:00
|
|
|
type init_op[T] = fn(uint i) -> T;
|
|
|
|
|
|
|
|
fn init_fn[T](&init_op[T] op, uint n_elts) -> vec[T] {
|
2010-09-22 17:44:13 -05:00
|
|
|
let vec[T] v = alloc[T](n_elts);
|
|
|
|
let uint i = 0u;
|
|
|
|
while (i < n_elts) {
|
|
|
|
v += vec(op(i));
|
|
|
|
i += 1u;
|
|
|
|
}
|
|
|
|
ret v;
|
2010-07-05 16:42:12 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 15:53:49 -05:00
|
|
|
fn init_fn_mut[T](&init_op[T] op, uint n_elts) -> vec[mutable T] {
|
|
|
|
let vec[mutable T] v = alloc_mut[T](n_elts);
|
|
|
|
let uint i = 0u;
|
|
|
|
while (i < n_elts) {
|
|
|
|
v += vec(mutable op(i));
|
|
|
|
i += 1u;
|
|
|
|
}
|
|
|
|
ret v;
|
|
|
|
}
|
|
|
|
|
2010-07-05 16:42:12 -05:00
|
|
|
fn init_elt[T](&T t, uint n_elts) -> vec[T] {
|
2010-09-22 17:44:13 -05:00
|
|
|
/**
|
|
|
|
* FIXME (issue #81): should be:
|
|
|
|
*
|
|
|
|
* fn elt_op[T](&T x, uint i) -> T { ret x; }
|
|
|
|
* let init_op[T] inner = bind elt_op[T](t, _);
|
|
|
|
* ret init_fn[T](inner, n_elts);
|
|
|
|
*/
|
|
|
|
let vec[T] v = alloc[T](n_elts);
|
|
|
|
let uint i = n_elts;
|
|
|
|
while (i > 0u) {
|
|
|
|
i -= 1u;
|
|
|
|
v += vec(t);
|
|
|
|
}
|
|
|
|
ret v;
|
2010-06-23 23:03:09 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 15:53:49 -05:00
|
|
|
fn init_elt_mut[T](&T t, uint n_elts) -> vec[mutable T] {
|
|
|
|
let vec[mutable T] v = alloc_mut[T](n_elts);
|
|
|
|
let uint i = n_elts;
|
|
|
|
while (i > 0u) {
|
|
|
|
i -= 1u;
|
|
|
|
v += vec(mutable t);
|
|
|
|
}
|
|
|
|
ret v;
|
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn buf[T](vec[mutable? T] v) -> vbuf {
|
2010-09-22 17:44:13 -05:00
|
|
|
ret rustrt.vec_buf[T](v, 0u);
|
2010-08-19 19:37:22 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn len[T](vec[mutable? T] v) -> uint {
|
2010-09-22 17:44:13 -05:00
|
|
|
ret rustrt.vec_len[T](v);
|
2010-06-23 23:03:09 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn len_set[T](vec[mutable? T] v, uint n) {
|
2010-09-22 17:44:13 -05:00
|
|
|
rustrt.vec_len_set[T](v, n);
|
2010-08-04 14:59:48 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn buf_off[T](vec[mutable? T] v, uint offset) -> vbuf {
|
2010-09-22 17:44:13 -05:00
|
|
|
check (offset < len[T](v));
|
|
|
|
ret rustrt.vec_buf[T](v, offset);
|
2010-06-23 23:03:09 -05:00
|
|
|
}
|
2010-06-29 01:18:51 -05:00
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn print_debug_info[T](vec[mutable? T] v) {
|
2010-09-22 17:44:13 -05:00
|
|
|
rustrt.vec_print_debug_info[T](v);
|
2010-08-12 15:11:49 -05:00
|
|
|
}
|
|
|
|
|
2011-03-21 19:21:35 -05:00
|
|
|
// Returns the last element of v.
|
|
|
|
fn last[T](vec[mutable? T] v) -> option.t[T] {
|
|
|
|
auto l = len[T](v);
|
|
|
|
if (l == 0u) {
|
|
|
|
ret none[T];
|
|
|
|
}
|
|
|
|
ret some[T](v.(l - 1u));
|
|
|
|
}
|
|
|
|
|
2010-07-11 16:51:02 -05:00
|
|
|
// Returns elements from [start..end) from v.
|
2011-03-18 16:01:03 -05:00
|
|
|
fn slice[T](vec[mutable? T] v, uint start, uint end) -> vec[T] {
|
2010-09-22 17:44:13 -05:00
|
|
|
check (start <= end);
|
2010-10-22 13:46:04 -05:00
|
|
|
check (end <= len[T](v));
|
|
|
|
auto result = alloc[T](end - start);
|
|
|
|
let uint i = start;
|
2010-09-22 17:44:13 -05:00
|
|
|
while (i < end) {
|
|
|
|
result += vec(v.(i));
|
2010-10-22 13:46:04 -05:00
|
|
|
i += 1u;
|
2010-09-22 17:44:13 -05:00
|
|
|
}
|
|
|
|
ret result;
|
2010-07-11 16:51:02 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn shift[T](&mutable vec[mutable? T] v) -> T {
|
2011-03-16 16:58:02 -05:00
|
|
|
auto ln = len[T](v);
|
|
|
|
check(ln > 0u);
|
|
|
|
auto e = v.(0);
|
|
|
|
v = slice[T](v, 1u, ln);
|
|
|
|
ret e;
|
2010-10-22 13:46:04 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn pop[T](&mutable vec[mutable? T] v) -> T {
|
2011-03-16 16:58:02 -05:00
|
|
|
auto ln = len[T](v);
|
|
|
|
check(ln > 0u);
|
|
|
|
ln -= 1u;
|
|
|
|
auto e = v.(ln);
|
|
|
|
v = slice[T](v, 0u, ln);
|
|
|
|
ret e;
|
2010-10-22 13:46:04 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn push[T](&mutable vec[mutable? T] v, &T t) {
|
2011-03-16 16:58:02 -05:00
|
|
|
v += vec(t);
|
2010-10-22 13:46:04 -05:00
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn unshift[T](&mutable vec[mutable? T] v, &T t) {
|
2010-10-22 13:46:04 -05:00
|
|
|
auto res = alloc[T](len[T](v) + 1u);
|
2011-03-16 16:58:02 -05:00
|
|
|
res += vec(t);
|
|
|
|
res += v;
|
|
|
|
v = res;
|
2010-10-22 13:46:04 -05:00
|
|
|
}
|
|
|
|
|
2011-04-15 19:44:52 -05:00
|
|
|
fn grow[T](&mutable vec[mutable? T] v, uint n, &T initval) {
|
|
|
|
let uint i = n;
|
|
|
|
while (i > 0u) {
|
|
|
|
i -= 1u;
|
2010-09-22 17:44:13 -05:00
|
|
|
v += vec(initval);
|
|
|
|
}
|
2010-06-29 01:18:51 -05:00
|
|
|
}
|
2010-07-05 16:42:12 -05:00
|
|
|
|
2011-04-15 19:44:52 -05:00
|
|
|
fn grow_set[T](&mutable vec[mutable T] v, uint index, &T initval, &T val) {
|
|
|
|
auto length = _vec.len[mutable T](v);
|
|
|
|
if (index >= length) {
|
|
|
|
grow[mutable T](v, index - length + 1u, initval);
|
|
|
|
}
|
|
|
|
v.(index) = val;
|
|
|
|
}
|
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn map[T, U](&option.operator[T,U] f, &vec[mutable? T] v) -> vec[U] {
|
2010-09-22 17:44:13 -05:00
|
|
|
let vec[U] u = alloc[U](len[T](v));
|
|
|
|
for (T ve in v) {
|
|
|
|
u += vec(f(ve));
|
|
|
|
}
|
|
|
|
ret u;
|
2010-07-05 16:42:12 -05:00
|
|
|
}
|
2010-09-22 17:44:13 -05:00
|
|
|
|
2011-03-18 16:01:03 -05:00
|
|
|
fn map2[T,U,V](&operator2[T,U,V] f, &vec[mutable? T] v0, &vec[mutable? U] v1)
|
|
|
|
-> vec[V] {
|
2010-11-09 17:35:40 -06:00
|
|
|
auto v0_len = len[T](v0);
|
|
|
|
if (v0_len != len[U](v1)) {
|
|
|
|
fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
let vec[V] u = alloc[V](v0_len);
|
|
|
|
auto i = 0u;
|
|
|
|
while (i < v0_len) {
|
2011-03-16 16:58:02 -05:00
|
|
|
u += vec(f(v0.(i), v1.(i)));
|
2010-11-09 17:35:40 -06:00
|
|
|
i += 1u;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret u;
|
|
|
|
}
|
|
|
|
|
2011-03-24 14:12:04 -05:00
|
|
|
fn find[T](fn (&T) -> bool f, &vec[mutable? T] v) -> option.t[T] {
|
|
|
|
for (T elt in v) {
|
|
|
|
if (f(elt)) {
|
|
|
|
ret some[T](elt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret none[T];
|
|
|
|
}
|
|
|
|
|
|
|
|
fn foldl[T, U](fn (&U, &T) -> U p, &U z, &vec[T] v) -> U {
|
|
|
|
auto sz = len[T](v);
|
|
|
|
|
|
|
|
if (sz == 0u) {
|
|
|
|
ret z;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
auto rest = slice[T](v, 1u, sz);
|
|
|
|
|
|
|
|
ret (p(foldl[T,U](p, z, rest), v.(0)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-06 19:56:44 -05:00
|
|
|
fn unzip[T, U](&vec[tup(T, U)] v) -> tup(vec[T], vec[U]) {
|
|
|
|
auto sz = len[tup(T, U)](v);
|
|
|
|
|
|
|
|
if (sz == 0u) {
|
|
|
|
ret tup(alloc[T](0u), alloc[U](0u));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
auto rest = slice[tup(T, U)](v, 1u, sz);
|
|
|
|
auto tl = unzip[T, U](rest);
|
|
|
|
auto a = vec(v.(0)._0);
|
|
|
|
auto b = vec(v.(0)._1);
|
|
|
|
ret tup(a + tl._0, b + tl._1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn or(&vec[bool] v) -> bool {
|
|
|
|
auto f = orb;
|
Handle nested items correctly in typestate_check
Summary says it all. Actually, only nested objects and functions
are handled, but that's better than before. The fold that I was using
before to traverse a crate wasn't working correctly, because annotations
have to reflect the number of local variables of the nearest enclosing
function (in turn, because annotations are represented as bit vectors).
The fold was traversing the AST in the wrong order, first filling in
the annotations correctly, but then re-traversing them with the bit
vector length for any outer nested functions, and so on.
Remedying this required writing a lot of tedious boilerplate code
because I scrapped the idea of using a fold altogether.
I also made typestate_check handle unary, field, alt, and fail.
Also, some miscellaneous changes:
* added annotations to blocks in typeck
* fix pprust so it can handle spawn
* added more logging functions in util.common
* fixed _vec.or
* added maybe and from_maybe in option
* removed fold_block field from ast_fold, since it was never used
2011-04-18 17:33:10 -05:00
|
|
|
ret _vec.foldl[bool, bool](f, false, v);
|
2011-04-06 19:56:44 -05:00
|
|
|
}
|
|
|
|
|
2011-04-13 17:34:10 -05:00
|
|
|
fn clone[T](&vec[T] v) -> vec[T] {
|
|
|
|
ret slice[T](v, 0u, len[T](v));
|
|
|
|
}
|
|
|
|
|
|
|
|
fn plus_option[T](&vec[T] v, &option.t[T] o) -> () {
|
|
|
|
alt (o) {
|
|
|
|
case (none[T]) {}
|
|
|
|
case (some[T](?x)) { v += vec(x); }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-15 19:44:52 -05:00
|
|
|
// TODO: Remove in favor of built-in "freeze" operation when it's implemented.
|
|
|
|
fn freeze[T](vec[mutable T] v) -> vec[T] {
|
|
|
|
let vec[T] result = vec();
|
|
|
|
for (T elem in v) {
|
|
|
|
result += vec(elem);
|
|
|
|
}
|
|
|
|
ret result;
|
|
|
|
}
|
|
|
|
|
2010-09-22 17:44:13 -05:00
|
|
|
// Local Variables:
|
|
|
|
// mode: rust;
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
|
|
|
|
// End:
|