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;
|
|
|
|
|
2011-04-28 19:15:32 -05:00
|
|
|
type array[T] = vec[mutable? T];
|
|
|
|
|
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];
|
2011-04-27 20:10:02 -05:00
|
|
|
|
|
|
|
fn unsafe_vec_to_mut[T](vec[T] v) -> vec[mutable 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-04-28 19:15:32 -05:00
|
|
|
fn refcount[T](array[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-04-28 19:15:32 -05:00
|
|
|
fn buf[T](array[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-04-28 19:15:32 -05:00
|
|
|
fn len[T](array[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-04-28 19:15:32 -05:00
|
|
|
fn len_set[T](array[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-04-28 19:15:32 -05:00
|
|
|
fn buf_off[T](array[T] v, uint offset) -> vbuf {
|
2011-05-02 18:24:09 -05:00
|
|
|
check (offset < len[T](v));
|
2010-09-22 17:44:13 -05:00
|
|
|
ret rustrt.vec_buf[T](v, offset);
|
2010-06-23 23:03:09 -05:00
|
|
|
}
|
2010-06-29 01:18:51 -05:00
|
|
|
|
2011-04-28 19:15:32 -05:00
|
|
|
fn print_debug_info[T](array[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.
|
2011-04-28 19:15:32 -05:00
|
|
|
fn last[T](array[T] v) -> option.t[T] {
|
2011-03-21 19:21:35 -05:00
|
|
|
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-04-28 19:15:32 -05:00
|
|
|
fn slice[T](array[T] v, uint start, uint end) -> vec[T] {
|
2011-05-02 18:24:09 -05:00
|
|
|
check (start <= end);
|
|
|
|
check (end <= len[T](v));
|
2010-10-22 13:46:04 -05:00
|
|
|
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-04-28 19:15:32 -05:00
|
|
|
fn shift[T](&mutable array[T] v) -> T {
|
2011-03-16 16:58:02 -05:00
|
|
|
auto ln = len[T](v);
|
2011-05-02 18:24:09 -05:00
|
|
|
check(ln > 0u);
|
2011-03-16 16:58:02 -05:00
|
|
|
auto e = v.(0);
|
|
|
|
v = slice[T](v, 1u, ln);
|
|
|
|
ret e;
|
2010-10-22 13:46:04 -05:00
|
|
|
}
|
|
|
|
|
2011-04-28 19:15:32 -05:00
|
|
|
fn pop[T](&mutable array[T] v) -> T {
|
2011-03-16 16:58:02 -05:00
|
|
|
auto ln = len[T](v);
|
2011-05-02 18:24:09 -05:00
|
|
|
check(ln > 0u);
|
2011-03-16 16:58:02 -05:00
|
|
|
ln -= 1u;
|
|
|
|
auto e = v.(ln);
|
|
|
|
v = slice[T](v, 0u, ln);
|
|
|
|
ret e;
|
2010-10-22 13:46:04 -05:00
|
|
|
}
|
|
|
|
|
2011-04-28 19:15:32 -05:00
|
|
|
fn push[T](&mutable array[T] v, &T t) {
|
2011-03-16 16:58:02 -05:00
|
|
|
v += vec(t);
|
2010-10-22 13:46:04 -05:00
|
|
|
}
|
|
|
|
|
2011-04-28 19:15:32 -05:00
|
|
|
fn unshift[T](&mutable array[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-28 19:15:32 -05:00
|
|
|
fn grow[T](&mutable array[T] v, uint n, &T initval) {
|
2011-04-15 19:44:52 -05:00
|
|
|
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-04-28 19:15:32 -05:00
|
|
|
fn map[T, U](&option.operator[T,U] f, &array[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-04-28 19:15:32 -05:00
|
|
|
fn map2[T,U,V](&operator2[T,U,V] f, &array[T] v0, &array[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-04-28 19:15:32 -05:00
|
|
|
fn find[T](fn (&T) -> bool f, &array[T] v) -> option.t[T] {
|
2011-03-24 14:12:04 -05:00
|
|
|
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); }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Further work on typestate_check
Lots of work on typestate_check, seems to get a lot of the way
through checking the standard library.
* Added for, for_each, assign_op, bind, cast, put, check, break,
and cont. (I'm not sure break and cont are actually handled correctly.)
* Fixed side-effect bug in seq_preconds so that unioning the
preconditions of a sequence of statements or expressions
is handled correctly.
* Pass poststate correctly through a stmt_decl.
* Handle expr_ret and expr_fail properly (after execution of a ret
or fail, everything is true -- this is needed to handle ifs and alts
where one branch is a ret or fail)
* Fixed bug in set_prestate_ann where a thing that needed to be
mutated wasn't getting passed as an alias
* Fixed bug in how expr_alt was treated (zero is not the identity
for intersect, who knew, right?)
* Update logging to reflect log_err vs. log
* Fixed find_locals so as to return all local decls and exclude
function arguments.
* Make union_postconds work on an empty vector (needed to handle
empty blocks correctly)
* Added _vec.cat_options, which takes a list of option[T] to a list
of T, ignoring any Nones
* Added two test cases.
2011-04-20 14:11:01 -05:00
|
|
|
fn cat_options[T](&vec[option.t[T]] v) -> vec[T] {
|
|
|
|
let vec[T] res = vec();
|
|
|
|
|
|
|
|
for (option.t[T] o in v) {
|
|
|
|
alt (o) {
|
|
|
|
case (none[T]) { }
|
|
|
|
case (some[T](?t)) {
|
|
|
|
res += vec(t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret res;
|
|
|
|
}
|
|
|
|
|
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:
|