mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

convert most of libstd over to structs

Browse Source
This commit is contained in:
Erick Tryzelaar 2013-01-22 08:44:24 -08:00
parent c15facb5c0
commit e84576b888
13 changed files with 544 additions and 418 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/compiletest/compiletest.rc
View File

@ -158,17 +158,10 @@ fn run_tests(config: config) {
}
fn test_opts(config: config) -> test::TestOpts {
{filter:
match config.filter {
option::Some(s) => option::Some(s),
option::None => option::None
},
run_ignored: config.run_ignored,
logfile:
match config.logfile {
option::Some(s) => option::Some(s.to_str()),
option::None => option::None
}
test::TestOpts {
filter: config.filter,
run_ignored: config.run_ignored,
logfile: config.logfile.map(|s| s.to_str()),
}
}

2
src/librustc/middle/lint.rs
View File

@ -287,7 +287,7 @@ fn get_lint_settings_level(settings: lint_settings,
// This is kind of unfortunate. It should be somewhere else, or we should use
// a persistent data structure...
fn clone_lint_modes(modes: lint_modes) -> lint_modes {
smallintmap::SmallIntMap_(@{v: copy modes.v})
smallintmap::SmallIntMap_(@smallintmap::SmallIntMap_ { v: copy modes.v })
}
type ctxt_ = {dict: lint_dict,

20
src/libstd/arena.rs
View File

@ -68,7 +68,11 @@ const tydesc_drop_glue_index: size_t = 3 as size_t;
// The way arena uses arrays is really deeply awful. The arrays are
// allocated, and have capacities reserved, but the fill for the array
// will always stay at 0.
type Chunk = {data: @[u8], mut fill: uint, is_pod: bool};
struct Chunk {
data: @[u8],
mut fill: uint,
is_pod: bool,
}
pub struct Arena {
// The head is seperated out from the list as a unbenchmarked
@ -93,13 +97,19 @@ impl Arena : Drop {
fn chunk(size: uint, is_pod: bool) -> Chunk {
let mut v: @[const u8] = @[];
unsafe { at_vec::raw::reserve(&mut v, size); }
{ data: unsafe { cast::transmute(v) }, mut fill: 0u, is_pod: is_pod }
Chunk {
data: unsafe { cast::transmute(v) },
fill: 0u,
is_pod: is_pod,
}
}
pub fn arena_with_size(initial_size: uint) -> Arena {
return Arena {mut head: chunk(initial_size, false),
mut pod_head: chunk(initial_size, true),
mut chunks: @Nil};
Arena {
head: chunk(initial_size, false),
pod_head: chunk(initial_size, true),
chunks: @Nil,
}
}
pub fn Arena() -> Arena {

39
src/libstd/deque.rs
View File

@ -61,10 +61,12 @@ pub fn create<T: Copy>() -> Deque<T> {
match (*elts).get_elt(i) { Some(move t) => t, _ => fail }
}
type Repr<T> = {mut nelts: uint,
mut lo: uint,
mut hi: uint,
elts: DVec<Cell<T>>};
struct Repr<T> {
mut nelts: uint,
mut lo: uint,
mut hi: uint,
elts: DVec<Cell<T>>,
}
impl <T: Copy> Repr<T>: Deque<T> {
fn size() -> uint { return self.nelts; }
@ -119,15 +121,14 @@ pub fn create<T: Copy>() -> Deque<T> {
}
}
let repr: Repr<T> = {
mut nelts: 0u,
mut lo: 0u,
mut hi: 0u,
elts:
dvec::from_vec(
vec::from_elem(initial_capacity, None))
let repr: Repr<T> = Repr {
nelts: 0u,
lo: 0u,
hi: 0u,
elts: dvec::from_vec(vec::from_elem(initial_capacity, None)),
};
(move repr) as Deque::<T>
repr as Deque::<T>
}
#[cfg(test)]
@ -254,7 +255,11 @@ mod tests {
Onepar(int), Twopar(int, int), Threepar(int, int, int),
}
type RecCy = {x: int, y: int, t: Taggy};
struct RecCy {
x: int,
y: int,
t: Taggy,
}
impl Taggy : Eq {
pure fn eq(&self, other: &Taggy) -> bool {
@ -335,10 +340,10 @@ mod tests {
#[test]
fn test_param_reccy() {
let reccy1: RecCy = {x: 1, y: 2, t: One(1)};
let reccy2: RecCy = {x: 345, y: 2, t: Two(1, 2)};
let reccy3: RecCy = {x: 1, y: 777, t: Three(1, 2, 3)};
let reccy4: RecCy = {x: 19, y: 252, t: Two(17, 42)};
let reccy1 = RecCy { x: 1, y: 2, t: One(1) };
let reccy2 = RecCy { x: 345, y: 2, t: Two(1, 2) };
let reccy3 = RecCy { x: 1, y: 777, t: Three(1, 2, 3) };
let reccy4 = RecCy { x: 19, y: 252, t: Two(17, 42) };
test_parameterized::<RecCy>(reccy1, reccy2, reccy3, reccy4);
}
}

22
src/libstd/map.rs
View File

@ -107,7 +107,11 @@ pub trait Map<K:Eq IterBytes Hash Copy, V: Copy> {
}
pub mod util {
pub type Rational = {num: int, den: int}; // : int::positive(*.den);
pub struct Rational {
// : int::positive(*.den);
num: int,
den: int,
}
pub pure fn rational_leq(x: Rational, y: Rational) -> bool {
// NB: Uses the fact that rationals have positive denominators WLOG:
@ -265,9 +269,11 @@ pub mod chained {
// consider rehashing if more 3/4 full
let nchains = vec::len(self.chains);
let load = {num: (self.count + 1u) as int,
den: nchains as int};
if !util::rational_leq(load, {num:3, den:4}) {
let load = util::Rational {
num: (self.count + 1u) as int,
den: nchains as int,
};
if !util::rational_leq(load, util::Rational {num:3, den:4}) {
self.rehash();
}
@ -324,9 +330,11 @@ pub mod chained {
// consider rehashing if more 3/4 full
let nchains = vec::len(self.chains);
let load = {num: (self.count + 1u) as int,
den: nchains as int};
if !util::rational_leq(load, {num:3, den:4}) {
let load = util::Rational {
num: (self.count + 1u) as int,
den: nchains as int,
};
if !util::rational_leq(load, util::Rational {num:3, den:4}) {
self.rehash();
}

50
src/libstd/net_ip.rs
View File

@ -48,9 +48,9 @@ pub enum IpAddr {
}
/// Human-friendly feedback on why a parse_addr attempt failed
pub type ParseAddrErr = {
err_msg: ~str
};
pub struct ParseAddrErr {
err_msg: ~str,
}
/**
* Convert a `IpAddr` to a str
@ -122,7 +122,7 @@ pub fn get_addr(node: &str, iotask: iotask)
log(debug, fmt!("slice len %?", len));
let handle = create_uv_getaddrinfo_t();
let handle_ptr = ptr::addr_of(&handle);
let handle_data: GetAddrData = {
let handle_data = GetAddrData {
output_ch: output_ch
};
let handle_data_ptr = ptr::addr_of(&handle_data);
@ -187,7 +187,7 @@ pub mod v4 {
}
// the simple, old style numberic representation of
// ipv4
pub type Ipv4Rep = { a: u8, b: u8, c: u8, d:u8 };
pub struct Ipv4Rep { a: u8, b: u8, c: u8, d: u8 }
pub trait AsUnsafeU32 {
unsafe fn as_u32() -> u32;
@ -207,14 +207,14 @@ pub mod v4 {
}
});
if parts.len() != 4 {
result::Err(fmt!("'%s' doesn't have 4 parts", ip))
}
else if parts.contains(&256) {
result::Err(fmt!("invalid octal in addr '%s'", ip))
}
else {
result::Ok({a: parts[0] as u8, b: parts[1] as u8,
c: parts[2] as u8, d: parts[3] as u8})
Err(fmt!("'%s' doesn't have 4 parts", ip))
} else if parts.contains(&256) {
Err(fmt!("invalid octal in addr '%s'", ip))
} else {
Ok(Ipv4Rep {
a: parts[0] as u8, b: parts[1] as u8,
c: parts[2] as u8, d: parts[3] as u8,
})
}
}
pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {
@ -223,7 +223,7 @@ pub mod v4 {
let ip_rep_result = parse_to_ipv4_rep(ip);
if result::is_err(&ip_rep_result) {
let err_str = result::get_err(&ip_rep_result);
return result::Err({err_msg: err_str})
return result::Err(ParseAddrErr { err_msg: err_str })
}
// ipv4_rep.as_u32 is unsafe :/
let input_is_inaddr_none =
@ -236,15 +236,16 @@ pub mod v4 {
let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name);
if result::is_err(&ref_ip_rep_result) {
let err_str = result::get_err(&ref_ip_rep_result);
return result::Err({err_msg: err_str})
return Err(ParseAddrErr { err_msg: err_str })
}
if result::get(&ref_ip_rep_result).as_u32() == INADDR_NONE &&
!input_is_inaddr_none {
return result::Err(
{err_msg: ~"uv_ip4_name produced invalid result."})
}
else {
result::Ok(Ipv4(copy(new_addr)))
Err(ParseAddrErr {
err_msg: ~"uv_ip4_name produced invalid result.",
})
} else {
Ok(Ipv4(copy(new_addr)))
}
}
}
@ -289,19 +290,18 @@ pub mod v6 {
// '::' appears to be uv_ip6_name() returns for bogus
// parses..
if ip != &"::" && reparsed_name == ~"::" {
result::Err({err_msg:fmt!("failed to parse '%s'",
ip)})
Err(ParseAddrErr { err_msg:fmt!("failed to parse '%s'", ip) })
}
else {
result::Ok(Ipv6(new_addr))
Ok(Ipv6(new_addr))
}
}
}
}
type GetAddrData = {
struct GetAddrData {
output_ch: oldcomm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
};
}
extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
res: *addrinfo) {

68
src/libstd/net_tcp.rs
View File

@ -83,10 +83,11 @@ pub fn TcpSocketBuf(data: @TcpBufferedSocketData) -> TcpSocketBuf {
}
/// Contains raw, string-based, error information returned from libuv
pub type TcpErrData = {
pub struct TcpErrData {
err_name: ~str,
err_msg: ~str
};
err_msg: ~str,
}
/// Details returned as part of a `result::err` result from `tcp::listen`
pub enum TcpListenErrData {
/**
@ -155,7 +156,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
let reader_po = oldcomm::Port::<result::Result<~[u8], TcpErrData>>();
let stream_handle_ptr = malloc_uv_tcp_t();
*(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
let socket_data = @{
let socket_data = @TcpSocketData {
reader_po: reader_po,
reader_ch: oldcomm::Chan(&reader_po),
stream_handle_ptr: stream_handle_ptr,
@ -231,7 +232,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
// ip or somesuch
let err_data = uv::ll::get_last_err_data(loop_ptr);
oldcomm::send((*conn_data_ptr).result_ch,
ConnFailure(err_data.to_tcp_err()));
ConnFailure(err_data));
uv::ll::set_data_for_uv_handle(stream_handle_ptr,
conn_data_ptr);
uv::ll::close(stream_handle_ptr,
@ -243,7 +244,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
// failure to create a tcp handle
let err_data = uv::ll::get_last_err_data(loop_ptr);
oldcomm::send((*conn_data_ptr).result_ch,
ConnFailure(err_data.to_tcp_err()));
ConnFailure(err_data));
}
}
}
@ -513,7 +514,7 @@ pub fn accept(new_conn: TcpNewConnection)
let iotask = (*server_data_ptr).iotask;
let stream_handle_ptr = malloc_uv_tcp_t();
*(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
let client_socket_data = @{
let client_socket_data = @TcpSocketData {
reader_po: reader_po,
reader_ch: oldcomm::Chan(&reader_po),
stream_handle_ptr : stream_handle_ptr,
@ -785,7 +786,7 @@ fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint,
* A buffered wrapper that you can cast as an `io::reader` or `io::writer`
*/
pub fn socket_buf(sock: TcpSocket) -> TcpSocketBuf {
TcpSocketBuf(@{ sock: move sock, mut buf: ~[] })
TcpSocketBuf(@TcpBufferedSocketData { sock: sock, buf: ~[] })
}
/// Convenience methods extending `net::tcp::tcp_socket`
@ -979,7 +980,7 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
match move read_result {
None => {
log(debug, ~"tcp::read: timed out..");
let err_data = {
let err_data = TcpErrData {
err_name: ~"TIMEOUT",
err_msg: ~"req timed out"
};
@ -1020,9 +1021,10 @@ fn read_stop_common_impl(socket_data: *TcpSocketData) ->
}
}
};
match oldcomm::recv(stop_po) {
Some(ref err_data) => result::Err(err_data.to_tcp_err()),
None => result::Ok(())
Some(move err_data) => Err(err_data),
None => Ok(())
}
}
}
@ -1108,8 +1110,8 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData,
// ownership of everything to the I/O task and let it deal with the
// aftermath, so we don't have to sit here blocking.
match oldcomm::recv(result_po) {
TcpWriteSuccess => result::Ok(()),
TcpWriteError(ref err_data) => result::Err(err_data.to_tcp_err())
TcpWriteSuccess => Ok(()),
TcpWriteError(move err_data) => Err(err_data)
}
}
}
@ -1118,15 +1120,15 @@ enum TcpNewConnection {
NewTcpConn(*uv::ll::uv_tcp_t)
}
type TcpListenFcData = {
struct TcpListenFcData {
server_stream_ptr: *uv::ll::uv_tcp_t,
stream_closed_ch: oldcomm::Chan<()>,
kill_ch: oldcomm::Chan<Option<TcpErrData>>,
on_connect_cb: fn~(*uv::ll::uv_tcp_t),
iotask: IoTask,
ipv6: bool,
mut active: bool
};
mut active: bool,
}
extern fn tcp_lfc_close_cb(handle: *uv::ll::uv_tcp_t) {
unsafe {
@ -1191,7 +1193,7 @@ trait ToTcpErr {
impl uv::ll::uv_err_data: ToTcpErr {
fn to_tcp_err() -> TcpErrData {
{ err_name: self.err_name, err_msg: self.err_msg }
TcpErrData { err_name: self.err_name, err_msg: self.err_msg }
}
}
@ -1244,9 +1246,9 @@ extern fn on_alloc_cb(handle: *libc::c_void,
}
}
type TcpSocketCloseData = {
closed_ch: oldcomm::Chan<()>
};
struct TcpSocketCloseData {
closed_ch: oldcomm::Chan<()>,
}
extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) {
unsafe {
@ -1273,19 +1275,19 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
let err_data = uv::ll::get_last_err_data(loop_ptr);
log(debug, ~"failure to write");
oldcomm::send((*write_data_ptr).result_ch,
TcpWriteError(err_data));
TcpWriteError(err_data.to_tcp_err()));
}
}
}
type WriteReqData = {
result_ch: oldcomm::Chan<TcpWriteResult>
};
struct WriteReqData {
result_ch: oldcomm::Chan<TcpWriteResult>,
}
type ConnectReqData = {
struct ConnectReqData {
result_ch: oldcomm::Chan<ConnAttempt>,
closed_signal_ch: oldcomm::Chan<()>
};
closed_signal_ch: oldcomm::Chan<()>,
}
extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) {
unsafe {
@ -1337,20 +1339,20 @@ enum ConnAttempt {
ConnFailure(uv::ll::uv_err_data)
}
type TcpSocketData = {
struct TcpSocketData {
reader_po: oldcomm::Port<result::Result<~[u8], TcpErrData>>,
reader_ch: oldcomm::Chan<result::Result<~[u8], TcpErrData>>,
stream_handle_ptr: *uv::ll::uv_tcp_t,
connect_req: uv::ll::uv_connect_t,
write_req: uv::ll::uv_write_t,
ipv6: bool,
iotask: IoTask
};
iotask: IoTask,
}
type TcpBufferedSocketData = {
struct TcpBufferedSocketData {
sock: TcpSocket,
mut buf: ~[u8]
};
mut buf: ~[u8],
}
//#[cfg(test)]
pub mod test {

138
src/libstd/rope.rs
View File

@ -595,12 +595,12 @@ pub mod node {
* string can be shared between several ropes, e.g. for indexing
* purposes.
*/
pub type Leaf = {
pub struct Leaf {
byte_offset: uint,
byte_len: uint,
char_len: uint,
content: @~str
};
byte_len: uint,
char_len: uint,
content: @~str,
}
/**
* A node obtained from the concatenation of two other nodes
@ -619,14 +619,14 @@ pub mod node {
*
* Used for rebalancing and to allocate stacks for traversals.
*/
pub type Concat = {
pub struct Concat {
//FIXME (#2744): Perhaps a `vec` instead of `left`/`right`
left: @Node,
right: @Node,
left: @Node,
right: @Node,
char_len: uint,
byte_len: uint,
height: uint
};
height: uint,
}
pub enum Node {
/// A leaf consisting in a `str`
@ -709,11 +709,12 @@ pub mod node {
pub fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint,
char_len: uint) -> @Node {
assert(byte_start + byte_len <= str::len(*str));
let candidate = @Leaf({
byte_offset: byte_start,
byte_len: byte_len,
char_len: char_len,
content: str});
let candidate = @Leaf(Leaf {
byte_offset: byte_start,
byte_len: byte_len,
char_len: char_len,
content: str,
});
if char_len <= hint_max_leaf_char_len {
return candidate;
} else {
@ -736,11 +737,11 @@ pub mod node {
else { hint_max_leaf_char_len };
let chunk_byte_len =
str::count_bytes(*str, offset, chunk_char_len);
nodes[i] = @Leaf({
nodes[i] = @Leaf(Leaf {
byte_offset: offset,
byte_len: chunk_byte_len,
char_len: chunk_char_len,
content: str
byte_len: chunk_byte_len,
char_len: chunk_char_len,
content: str,
});
offset += chunk_byte_len;
@ -767,15 +768,15 @@ pub mod node {
pub pure fn byte_len(node: @Node) -> uint {
//FIXME (#2744): Could we do this without the pattern-matching?
match (*node) {
Leaf(y) => return y.byte_len,
Concat(ref y) => return y.byte_len
Leaf(y) => y.byte_len,
Concat(ref y) => y.byte_len
}
}
pub pure fn char_len(node: @Node) -> uint {
match (*node) {
Leaf(y) => return y.char_len,
Concat(ref y) => return y.char_len
Leaf(y) => y.char_len,
Concat(ref y) => y.char_len
}
}
@ -867,15 +868,15 @@ pub mod node {
pub fn flatten(node: @Node) -> @Node {
unsafe {
match (*node) {
Leaf(_) => return node,
Concat(ref x) => {
return @Leaf({
byte_offset: 0u,
byte_len: x.byte_len,
char_len: x.char_len,
content: @serialize_node(node)
})
}
Leaf(_) => node,
Concat(ref x) => {
@Leaf(Leaf {
byte_offset: 0u,
byte_len: x.byte_len,
char_len: x.char_len,
content: @serialize_node(node),
})
}
}
}
}
@ -943,10 +944,12 @@ pub mod node {
node::Leaf(x) => {
let char_len =
str::count_chars(*x.content, byte_offset, byte_len);
return @Leaf({byte_offset: byte_offset,
byte_len: byte_len,
char_len: char_len,
content: x.content});
return @Leaf(Leaf {
byte_offset: byte_offset,
byte_len: byte_len,
char_len: char_len,
content: x.content,
});
}
node::Concat(ref x) => {
let left_len: uint = node::byte_len(x.left);
@ -1007,10 +1010,12 @@ pub mod node {
str::count_bytes(*x.content, 0u, char_offset);
let byte_len =
str::count_bytes(*x.content, byte_offset, char_len);
return @Leaf({byte_offset: byte_offset,
byte_len: byte_len,
char_len: char_len,
content: x.content});
return @Leaf(Leaf {
byte_offset: byte_offset,
byte_len: byte_len,
char_len: char_len,
content: x.content,
});
}
node::Concat(ref x) => {
if char_offset == 0u && char_len == x.char_len {return node;}
@ -1040,18 +1045,19 @@ pub mod node {
}
pub fn concat2(left: @Node, right: @Node) -> @Node {
return @Concat({left : left,
right : right,
char_len: char_len(left) + char_len(right),
byte_len: byte_len(left) + byte_len(right),
height: uint::max(height(left), height(right)) + 1u
})
@Concat(Concat {
left: left,
right: right,
char_len: char_len(left) + char_len(right),
byte_len: byte_len(left) + byte_len(right),
height: uint::max(height(left), height(right)) + 1u,
})
}
pub pure fn height(node: @Node) -> uint {
match (*node) {
Leaf(_) => return 0u,
Concat(ref x) => return x.height
Leaf(_) => 0u,
Concat(ref x) => x.height,
}
}
@ -1135,7 +1141,7 @@ pub mod node {
loop {
match *node {
Leaf(x) => return str::char_at(*x.content, pos),
Concat({left, right, _}) => {
Concat(Concat {left, right, _}) => {
let left_len = char_len(left);
node = if left_len > pos { left }
else { pos -= left_len; right };
@ -1151,22 +1157,22 @@ pub mod node {
use core::prelude::*;
use core::vec;
pub type T = {
stack: ~[mut @Node],
mut stackpos: int
};
pub struct T {
stack: ~[mut @Node],
mut stackpos: int,
}
pub fn empty() -> T {
let stack : ~[mut @Node] = ~[mut];
return {stack: move stack, mut stackpos: -1}
T { stack: stack, stackpos: -1 }
}
pub fn start(node: @Node) -> T {
let stack = vec::cast_to_mut(
vec::from_elem(height(node)+1u, node));
return {
stack: move stack,
mut stackpos: 0
T {
stack: stack,
stackpos: 0,
}
}
@ -1196,25 +1202,25 @@ pub mod node {
use core::prelude::*;
use core::str;
pub type T = {
pub struct T {
leaf_iterator: leaf_iterator::T,
mut leaf: Option<Leaf>,
mut leaf_byte_pos: uint
};
mut leaf_byte_pos: uint,
}
pub fn start(node: @Node) -> T {
return {
T {
leaf_iterator: leaf_iterator::start(node),
mut leaf: option::None,
mut leaf_byte_pos: 0u
leaf: option::None,
leaf_byte_pos: 0u,
}
}
pub fn empty() -> T {
return {
T {
leaf_iterator: leaf_iterator::empty(),
mut leaf: option::None,
mut leaf_byte_pos: 0u
leaf: option::None,
leaf_byte_pos: 0u,
}
}

100
src/libstd/sha1.rs
View File

@ -284,7 +284,10 @@ mod tests {
#[test]
fn test() {
unsafe {
type Test = {input: ~str, output: ~[u8]};
struct Test {
input: ~str,
output: ~[u8],
}
fn a_million_letter_a() -> ~str {
let mut i = 0;
@ -297,47 +300,64 @@ mod tests {
}
// Test messages from FIPS 180-1
let fips_180_1_tests: ~[Test] =
~[{input: ~"abc",
output:
~[0xA9u8, 0x99u8, 0x3Eu8, 0x36u8,
0x47u8, 0x06u8, 0x81u8, 0x6Au8,
0xBAu8, 0x3Eu8, 0x25u8, 0x71u8,
0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]},
{input:
~"abcdbcdecdefdefgefghfghighij" +
~"hijkijkljklmklmnlmnomnopnopq",
output:
~[0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8,
0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
0xE5u8, 0x46u8, 0x70u8, 0xF1u8]},
{input: a_million_letter_a(),
output:
~[0x34u8, 0xAAu8, 0x97u8, 0x3Cu8,
0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8,
0xDBu8, 0xADu8, 0x27u8, 0x31u8,
0x65u8, 0x34u8, 0x01u8, 0x6Fu8]}];
let fips_180_1_tests = ~[
Test {
input: ~"abc",
output: ~[
0xA9u8, 0x99u8, 0x3Eu8, 0x36u8,
0x47u8, 0x06u8, 0x81u8, 0x6Au8,
0xBAu8, 0x3Eu8, 0x25u8, 0x71u8,
0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8,
],
},
Test {
input:
~"abcdbcdecdefdefgefghfghighij" +
~"hijkijkljklmklmnlmnomnopnopq",
output: ~[
0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8,
0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
0xE5u8, 0x46u8, 0x70u8, 0xF1u8,
],
},
Test {
input: a_million_letter_a(),
output: ~[
0x34u8, 0xAAu8, 0x97u8, 0x3Cu8,
0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8,
0xDBu8, 0xADu8, 0x27u8, 0x31u8,
0x65u8, 0x34u8, 0x01u8, 0x6Fu8,
],
},
];
// Examples from wikipedia
let wikipedia_tests: ~[Test] =
~[{input: ~"The quick brown fox jumps over the lazy dog",
output:
~[0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8,
0x7au8, 0x2du8, 0x28u8, 0xfcu8,
0xedu8, 0x84u8, 0x9eu8, 0xe1u8,
0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
0x1bu8, 0x93u8, 0xebu8, 0x12u8]},
{input: ~"The quick brown fox jumps over the lazy cog",
output:
~[0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8,
0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
0xfau8, 0xd3u8, 0xe8u8, 0x5au8,
0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
let wikipedia_tests = ~[
Test {
input: ~"The quick brown fox jumps over the lazy dog",
output: ~[
0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8,
0x7au8, 0x2du8, 0x28u8, 0xfcu8,
0xedu8, 0x84u8, 0x9eu8, 0xe1u8,
0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
0x1bu8, 0x93u8, 0xebu8, 0x12u8,
],
},
Test {
input: ~"The quick brown fox jumps over the lazy cog",
output: ~[
0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8,
0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
0xfau8, 0xd3u8, 0xe8u8, 0x5au8,
0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
0x10u8, 0x0du8, 0xb4u8, 0xb3u8,
],
},
];
let tests = fips_180_1_tests + wikipedia_tests;
fn check_vec_eq(v0: ~[u8], v1: ~[u8]) {
assert (vec::len::<u8>(v0) == vec::len::<u8>(v1));

6
src/libstd/smallintmap.rs
View File

@ -25,7 +25,9 @@ use core::prelude::*;
// FIXME (#2347): Should not be @; there's a bug somewhere in rustc that
// requires this to be.
type SmallIntMap_<T: Copy> = {v: DVec<Option<T>>};
struct SmallIntMap_<T: Copy> {
v: DVec<Option<T>>,
}
pub enum SmallIntMap<T:Copy> {
SmallIntMap_(@SmallIntMap_<T>)
@ -34,7 +36,7 @@ pub enum SmallIntMap<T:Copy> {
/// Create a smallintmap
pub fn mk<T: Copy>() -> SmallIntMap<T> {
let v = DVec();
return SmallIntMap_(@{v: move v});
SmallIntMap_(@SmallIntMap_ { v: v } )
}
/**

57
src/libstd/test.rs
View File

@ -74,8 +74,11 @@ pub fn test_main(args: &[~str], tests: &[TestDesc]) {
if !run_tests_console(&opts, tests) { fail ~"Some tests failed"; }
}
pub type TestOpts = {filter: Option<~str>, run_ignored: bool,
logfile: Option<~str>};
pub struct TestOpts {
filter: Option<~str>,
run_ignored: bool,
logfile: Option<~str>,
}
type OptRes = Either<TestOpts, ~str>;
@ -97,10 +100,13 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
let run_ignored = getopts::opt_present(&matches, ~"ignored");
let logfile = getopts::opt_maybe_str(&matches, ~"logfile");
let test_opts = {filter: filter, run_ignored: run_ignored,
logfile: logfile};
let test_opts = TestOpts {
filter: filter,
run_ignored: run_ignored,
logfile: logfile,
};
return either::Left(test_opts);
either::Left(test_opts)
}
#[deriving_eq]
@ -396,7 +402,10 @@ pub fn filter_tests(opts: &TestOpts,
move filtered
}
type TestFuture = {test: TestDesc, wait: fn@() -> TestResult};
struct TestFuture {
test: TestDesc,
wait: fn@() -> TestResult,
}
pub fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan<MonitorMsg>) {
if test.ignore {
@ -431,7 +440,7 @@ mod tests {
#[legacy_exports];
use test::{TrFailed, TrIgnored, TrOk, filter_tests, parse_opts, TestDesc};
use test::{run_test};
use test::{TestOpts, run_test};
use core::either;
use core::oldcomm;
@ -528,13 +537,26 @@ mod tests {
// When we run ignored tests the test filter should filter out all the
// unignored tests and flip the ignore flag on the rest to false
let opts = {filter: option::None, run_ignored: true,
logfile: option::None};
let tests =
~[TestDesc {name: ~"1", testfn: fn~() { },
ignore: true, should_fail: false},
TestDesc {name: ~"2", testfn: fn~() { },
ignore: false, should_fail: false}];
let opts = TestOpts {
filter: option::None,
run_ignored: true,
logfile: option::None,
};
let tests = ~[
TestDesc {
name: ~"1",
testfn: fn~() { },
ignore: true,
should_fail: false,
},
TestDesc {
name: ~"2",
testfn: fn~() { },
ignore: false,
should_fail: false,
},
];
let filtered = filter_tests(&opts, tests);
assert (vec::len(filtered) == 1u);
@ -544,8 +566,11 @@ mod tests {
#[test]
fn sort_tests() {
let opts = {filter: option::None, run_ignored: false,
logfile: option::None};
let opts = TestOpts {
filter: option::None,
run_ignored: false,
logfile: option::None,
};
let names =
~[~"sha1::test", ~"int::test_to_str", ~"int::test_pow",

14
src/libstd/uv_iotask.rs
View File

@ -111,7 +111,7 @@ fn run_loop(iotask_ch: Chan<IoTask>) {
ll::async_init(loop_ptr, async_handle, wake_up_cb);
// initialize our loop data and store it in the loop
let data: IoTaskLoopData = {
let data = IoTaskLoopData {
async_handle: async_handle,
msg_po: Port()
};
@ -134,10 +134,10 @@ fn run_loop(iotask_ch: Chan<IoTask>) {
}
// data that lives for the lifetime of the high-evel oo
type IoTaskLoopData = {
struct IoTaskLoopData {
async_handle: *ll::uv_async_t,
msg_po: Port<IoTaskMsg>
};
msg_po: Port<IoTaskMsg>,
}
fn send_msg(iotask: IoTask, msg: IoTaskMsg) {
unsafe {
@ -214,10 +214,10 @@ mod test {
ll::close(handle, async_close_cb);
}
}
type AhData = {
struct AhData {
iotask: IoTask,
exit_ch: oldcomm::Chan<()>
};
exit_ch: oldcomm::Chan<()>,
}
fn impl_uv_iotask_async(iotask: IoTask) {
unsafe {
let async_handle = ll::async_t();

431
src/libstd/uv_ll.rs
View File

@ -41,10 +41,10 @@ use core::str;
use core::vec;
// libuv struct mappings
pub type uv_ip4_addr = {
pub struct uv_ip4_addr {
ip: ~[u8],
port: int
};
port: int,
}
pub type uv_ip6_addr = uv_ip4_addr;
pub enum uv_handle_type {
@ -67,31 +67,31 @@ pub enum uv_handle_type {
pub type handle_type = libc::c_uint;
pub type uv_handle_fields = {
pub struct uv_handle_fields {
loop_handle: *libc::c_void,
type_: handle_type,
close_cb: *u8,
mut data: *libc::c_void,
};
}
// unix size: 8
pub type uv_err_t = {
pub struct uv_err_t {
code: libc::c_int,
sys_errno_: libc::c_int
};
}
// don't create one of these directly. instead,
// count on it appearing in libuv callbacks or embedded
// in other types as a pointer to be used in other
// operations (so mostly treat it as opaque, once you
// have it in this form..)
pub type uv_stream_t = {
fields: uv_handle_fields
};
pub struct uv_stream_t {
fields: uv_handle_fields,
}
// 64bit unix size: 272
#[cfg(unix)]
pub type uv_tcp_t = {
pub struct uv_tcp_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
@ -101,24 +101,24 @@ pub type uv_tcp_t = {
a20: *u8, a21: *u8, a22: *u8, a23: *u8,
a24: *u8, a25: *u8, a26: *u8, a27: *u8,
a28: *u8,
a30: uv_tcp_t_32bit_unix_riders
};
a30: uv_tcp_t_32bit_unix_riders,
}
// 32bit unix size: 328 (164)
#[cfg(target_arch="x86_64")]
pub type uv_tcp_t_32bit_unix_riders = {
a29: *u8
};
pub struct uv_tcp_t_32bit_unix_riders {
a29: *u8,
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub type uv_tcp_t_32bit_unix_riders = {
pub struct uv_tcp_t_32bit_unix_riders {
a29: *u8, a30: *u8, a31: *u8,
a32: *u8, a33: *u8, a34: *u8,
a35: *u8, a36: *u8
};
a35: *u8, a36: *u8,
}
// 32bit win32 size: 240 (120)
#[cfg(windows)]
pub type uv_tcp_t = {
pub struct uv_tcp_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
@ -126,140 +126,140 @@ pub type uv_tcp_t = {
a12: *u8, a13: *u8, a14: *u8, a15: *u8,
a16: *u8, a17: *u8, a18: *u8, a19: *u8,
a20: *u8, a21: *u8, a22: *u8, a23: *u8,
a24: *u8, a25: *u8
};
a24: *u8, a25: *u8,
}
// unix size: 48
#[cfg(unix)]
pub type uv_connect_t = {
pub struct uv_connect_t {
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8
};
a04: *u8, a05: *u8,
}
// win32 size: 88 (44)
#[cfg(windows)]
pub type uv_connect_t = {
pub struct uv_connect_t {
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
a08: *u8, a09: *u8, a10: *u8
};
a08: *u8, a09: *u8, a10: *u8,
}
// unix size: 16
pub type uv_buf_t = {
pub struct uv_buf_t {
base: *u8,
len: libc::size_t
};
len: libc::size_t,
}
// no gen stub method.. should create
// it via uv::direct::buf_init()
// unix size: 144
#[cfg(unix)]
pub type uv_write_t = {
pub struct uv_write_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
a08: *u8, a09: *u8, a10: *u8, a11: *u8,
a12: *u8,
a14: uv_write_t_32bit_unix_riders
};
a14: uv_write_t_32bit_unix_riders,
}
#[cfg(target_arch="x86_64")]
pub type uv_write_t_32bit_unix_riders = {
a13: *u8
};
pub struct uv_write_t_32bit_unix_riders {
a13: *u8,
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub type uv_write_t_32bit_unix_riders = {
a13: *u8, a14: *u8
};
pub struct uv_write_t_32bit_unix_riders {
a13: *u8, a14: *u8,
}
// win32 size: 136 (68)
#[cfg(windows)]
pub type uv_write_t = {
pub struct uv_write_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
a08: *u8, a09: *u8, a10: *u8, a11: *u8,
a12: *u8
};
a12: *u8,
}
// 64bit unix size: 120
// 32bit unix size: 152 (76)
#[cfg(unix)]
pub type uv_async_t = {
pub struct uv_async_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
a08: *u8, a09: *u8,
a11: uv_async_t_32bit_unix_riders
};
a11: uv_async_t_32bit_unix_riders,
}
#[cfg(target_arch="x86_64")]
pub type uv_async_t_32bit_unix_riders = {
a10: *u8
};
pub struct uv_async_t_32bit_unix_riders {
a10: *u8,
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub type uv_async_t_32bit_unix_riders = {
a10: *u8, a11: *u8, a12: *u8, a13: *u8
};
pub struct uv_async_t_32bit_unix_riders {
a10: *u8, a11: *u8, a12: *u8, a13: *u8,
}
// win32 size 132 (68)
#[cfg(windows)]
pub type uv_async_t = {
pub struct uv_async_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
a08: *u8, a09: *u8, a10: *u8, a11: *u8,
a12: *u8
};
a12: *u8,
}
// 64bit unix size: 128
// 32bit unix size: 84
#[cfg(unix)]
pub type uv_timer_t = {
pub struct uv_timer_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
a08: *u8, a09: *u8,
a11: uv_timer_t_32bit_unix_riders
};
a11: uv_timer_t_32bit_unix_riders,
}
#[cfg(target_arch="x86_64")]
pub type uv_timer_t_32bit_unix_riders = {
a10: *u8, a11: *u8
};
pub struct uv_timer_t_32bit_unix_riders {
a10: *u8, a11: *u8,
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub type uv_timer_t_32bit_unix_riders = {
pub struct uv_timer_t_32bit_unix_riders {
a10: *u8, a11: *u8, a12: *u8, a13: *u8,
a14: *u8, a15: *u8, a16: *u8
};
a14: *u8, a15: *u8, a16: *u8,
}
// win32 size: 64
#[cfg(windows)]
pub type uv_timer_t = {
pub struct uv_timer_t {
fields: uv_handle_fields,
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
a08: *u8, a09: *u8, a10: *u8, a11: *u8
};
a08: *u8, a09: *u8, a10: *u8, a11: *u8,
}
// unix size: 16
pub type sockaddr_in = {
pub struct sockaddr_in {
mut sin_family: u16,
mut sin_port: u16,
mut sin_addr: u32, // in_addr: this is an opaque, per-platform struct
mut sin_zero: (u8, u8, u8, u8, u8, u8, u8, u8)
};
mut sin_zero: (u8, u8, u8, u8, u8, u8, u8, u8),
}
// unix size: 28 .. FIXME #1645
// stuck with 32 becuse of rust padding structs?
#[cfg(target_arch="x86_64")]
pub type sockaddr_in6 = {
pub struct sockaddr_in6 {
a0: *u8, a1: *u8,
a2: *u8, a3: *u8
};
a2: *u8, a3: *u8,
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub type sockaddr_in6 = {
pub struct sockaddr_in6 {
a0: *u8, a1: *u8,
a2: *u8, a3: *u8,
a4: *u8, a5: *u8,
a6: *u8, a7: *u8
};
a6: *u8, a7: *u8,
}
// unix size: 28 .. FIXME #1645
// stuck with 32 becuse of rust padding structs?
@ -267,25 +267,25 @@ pub type addr_in = addr_in_impl::addr_in;
#[cfg(unix)]
pub mod addr_in_impl {
#[cfg(target_arch="x86_64")]
pub type addr_in = {
pub struct addr_in {
a0: *u8, a1: *u8,
a2: *u8, a3: *u8
};
a2: *u8, a3: *u8,
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub type addr_in = {
pub struct addr_in {
a0: *u8, a1: *u8,
a2: *u8, a3: *u8,
a4: *u8, a5: *u8,
a6: *u8, a7: *u8,
};
}
}
#[cfg(windows)]
pub mod addr_in_impl {
pub type addr_in = {
pub struct addr_in {
a0: *u8, a1: *u8,
a2: *u8, a3: *u8
};
a2: *u8, a3: *u8,
}
}
// unix size: 48, 32bit: 32
@ -294,42 +294,60 @@ pub type addrinfo = addrinfo_impl::addrinfo;
#[cfg(target_os="android")]
pub mod addrinfo_impl {
#[cfg(target_arch="x86_64")]
pub type addrinfo = {
pub struct addrinfo {
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8
};
a04: *u8, a05: *u8,
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub type addrinfo = {
pub struct addrinfo {
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8, a06: *u8, a07: *u8
};
a04: *u8, a05: *u8, a06: *u8, a07: *u8,
}
}
#[cfg(target_os="macos")]
#[cfg(target_os="freebsd")]
pub mod addrinfo_impl {
pub type addrinfo = {
pub struct addrinfo {
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8
};
a04: *u8, a05: *u8,
}
}
#[cfg(windows)]
pub mod addrinfo_impl {
pub type addrinfo = {
pub struct addrinfo {
a00: *u8, a01: *u8, a02: *u8, a03: *u8,
a04: *u8, a05: *u8
};
a04: *u8, a05: *u8,
}
}
// unix size: 72
pub type uv_getaddrinfo_t = {
pub struct uv_getaddrinfo_t {
a00: *u8, a01: *u8, a02: *u8, a03: *u8, a04: *u8, a05: *u8,
a06: *u8, a07: *u8, a08: *u8
};
a06: *u8, a07: *u8, a08: *u8,
}
pub mod uv_ll_struct_stubgen {
use uv_ll::{uv_async_t, uv_connect_t, uv_getaddrinfo_t, uv_tcp_t};
use uv_ll::{uv_timer_t, uv_write_t};
use uv_ll::{
uv_async_t,
uv_connect_t,
uv_getaddrinfo_t,
uv_handle_fields,
uv_tcp_t,
uv_timer_t,
uv_write_t,
};
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
#[cfg(target_os = "macos")]
#[cfg(target_os = "freebsd")]
use uv_ll::{
uv_async_t_32bit_unix_riders,
uv_tcp_t_32bit_unix_riders,
uv_timer_t_32bit_unix_riders,
uv_write_t_32bit_unix_riders,
};
use core::ptr;
@ -343,9 +361,12 @@ pub mod uv_ll_struct_stubgen {
return gen_stub_arch();
#[cfg(target_arch="x86_64")]
pub fn gen_stub_arch() -> uv_tcp_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_tcp_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@ -361,17 +382,18 @@ pub mod uv_ll_struct_stubgen {
a24: 0 as *u8, a25: 0 as *u8, a26: 0 as *u8,
a27: 0 as *u8,
a28: 0 as *u8,
a30: {
a29: 0 as *u8
}
};
a30: uv_tcp_t_32bit_unix_riders { a29: 0 as *u8 },
}
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub fn gen_stub_arch() -> uv_tcp_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_tcp_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@ -387,19 +409,22 @@ pub mod uv_ll_struct_stubgen {
a24: 0 as *u8, a25: 0 as *u8, a26: 0 as *u8,
a27: 0 as *u8,
a28: 0 as *u8,
a30: {
a30: uv_tcp_t_32bit_unix_riders {
a29: 0 as *u8, a30: 0 as *u8, a31: 0 as *u8,
a32: 0 as *u8, a33: 0 as *u8, a34: 0 as *u8,
a35: 0 as *u8, a36: 0 as *u8
}
};
a35: 0 as *u8, a36: 0 as *u8,
},
}
}
}
#[cfg(windows)]
pub fn gen_stub_os() -> uv_tcp_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_tcp_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@ -412,58 +437,62 @@ pub mod uv_ll_struct_stubgen {
a19: 0 as *u8,
a20: 0 as *u8, a21: 0 as *u8, a22: 0 as *u8,
a23: 0 as *u8,
a24: 0 as *u8, a25: 0 as *u8
};
a24: 0 as *u8, a25: 0 as *u8,
}
}
}
#[cfg(unix)]
pub fn gen_stub_uv_connect_t() -> uv_connect_t {
return {
uv_connect_t {
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8
};
a04: 0 as *u8, a05: 0 as *u8,
}
}
#[cfg(windows)]
pub fn gen_stub_uv_connect_t() -> uv_connect_t {
return {
uv_connect_t {
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8
};
a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
}
}
#[cfg(unix)]
pub fn gen_stub_uv_async_t() -> uv_async_t {
return gen_stub_arch();
#[cfg(target_arch = "x86_64")]
pub fn gen_stub_arch() -> uv_async_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_async_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8,
a11: {
a10: 0 as *u8
}
};
a11: uv_async_t_32bit_unix_riders { a10: 0 as *u8 },
}
}
#[cfg(target_arch = "x86")]
#[cfg(target_arch="arm")]
pub fn gen_stub_arch() -> uv_async_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_async_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8,
a11: {
a11: uv_async_t_32bit_unix_riders {
a10: 0 as *u8, a11: 0 as *u8,
a12: 0 as *u8, a13: 0 as *u8
}
@ -472,107 +501,133 @@ pub mod uv_ll_struct_stubgen {
}
#[cfg(windows)]
pub fn gen_stub_uv_async_t() -> uv_async_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_async_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
a11: 0 as *u8,
a12: 0 as *u8
};
a12: 0 as *u8,
}
}
#[cfg(unix)]
pub fn gen_stub_uv_timer_t() -> uv_timer_t {
return gen_stub_arch();
#[cfg(target_arch = "x86_64")]
pub fn gen_stub_arch() -> uv_timer_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_timer_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8,
a11: {
a11: uv_timer_t_32bit_unix_riders {
a10: 0 as *u8, a11: 0 as *u8
}
};
},
}
}
#[cfg(target_arch = "x86")]
#[cfg(target_arch="arm")]
pub fn gen_stub_arch() -> uv_timer_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_timer_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8,
a11: {
a11: uv_timer_t_32bit_unix_riders {
a10: 0 as *u8, a11: 0 as *u8,
a12: 0 as *u8, a13: 0 as *u8,
a14: 0 as *u8, a15: 0 as *u8,
a16: 0 as *u8
}
};
a16: 0 as *u8,
},
}
}
}
#[cfg(windows)]
pub fn gen_stub_uv_timer_t() -> uv_timer_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_timer_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
a11: 0 as *u8
};
a11: 0 as *u8,
}
}
#[cfg(unix)]
pub fn gen_stub_uv_write_t() -> uv_write_t {
return gen_stub_arch();
#[cfg(target_arch="x86_64")]
pub fn gen_stub_arch() -> uv_write_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_write_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
a11: 0 as *u8,
a12: 0 as *u8, a14: { a13: 0 as *u8 }
};
a12: 0 as *u8,
a14: uv_write_t_32bit_unix_riders { a13: 0 as *u8 },
}
}
#[cfg(target_arch="x86")]
#[cfg(target_arch="arm")]
pub fn gen_stub_arch() -> uv_write_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_write_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
a07: 0 as *u8,
a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
a11: 0 as *u8,
a12: 0 as *u8, a14: { a13: 0 as *u8, a14: 0 as *u8 }
a12: 0 as *u8,
a14: uv_write_t_32bit_unix_riders {
a13: 0 as *u8,
a14: 0 as *u8,
}
};
}
}
#[cfg(windows)]
pub fn gen_stub_uv_write_t() -> uv_write_t {
return { fields: { loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
mut data: ptr::null() },
uv_write_t {
fields: uv_handle_fields {
loop_handle: ptr::null(), type_: 0u32,
close_cb: ptr::null(),
data: ptr::null(),
},
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@ -583,7 +638,7 @@ pub mod uv_ll_struct_stubgen {
};
}
pub fn gen_stub_uv_getaddrinfo_t() -> uv_getaddrinfo_t {
{
uv_getaddrinfo_t {
a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8,
a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8,
a08: 0 as *u8
@ -851,7 +906,7 @@ pub unsafe fn async_send(async_handle: *uv_async_t) {
return rustrt::rust_uv_async_send(async_handle);
}
pub unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t {
let out_buf = { base: ptr::null(), len: 0 as libc::size_t };
let out_buf = uv_buf_t { base: ptr::null(), len: 0 as libc::size_t };
let out_buf_ptr = ptr::addr_of(&out_buf);
log(debug, fmt!("buf_init - input %u len %u out_buf: %u",
input as uint,
@ -1043,13 +1098,13 @@ pub unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
let err_ptr = ptr::addr_of(&err);
let err_name = str::raw::from_c_str(err_name(err_ptr));
let err_msg = str::raw::from_c_str(strerror(err_ptr));
{ err_name: err_name, err_msg: err_msg }
uv_err_data { err_name: err_name, err_msg: err_msg }
}
pub type uv_err_data = {
pub struct uv_err_data {
err_name: ~str,
err_msg: ~str
};
err_msg: ~str,
}
pub unsafe fn is_ipv4_addrinfo(input: *addrinfo) -> bool {
rustrt::rust_uv_is_ipv4_addrinfo(input)
@ -1090,11 +1145,11 @@ pub mod test {
tcp_read_error
}
type request_wrapper = {
struct request_wrapper {
write_req: *uv_write_t,
req_buf: *~[uv_buf_t],
read_chan: *oldcomm::Chan<~str>
};
read_chan: *oldcomm::Chan<~str>,
}
extern fn after_close_cb(handle: *libc::c_void) {
log(debug, fmt!("after uv_close! handle ptr: %?",
@ -1424,18 +1479,18 @@ pub mod test {
}
}
type tcp_server_data = {
struct tcp_server_data {
client: *uv_tcp_t,
server: *uv_tcp_t,
server_kill_msg: ~str,
server_resp_buf: *~[uv_buf_t],
server_chan: *oldcomm::Chan<~str>,
server_write_req: *uv_write_t
};
server_write_req: *uv_write_t,
}
type async_handle_data = {
continue_chan: *oldcomm::Chan<bool>
};
struct async_handle_data {
continue_chan: *oldcomm::Chan<bool>,
}
extern fn async_close_cb(handle: *libc::c_void) {
log(debug, fmt!("SERVER: closing async cb... h: %?",
@ -1489,7 +1544,7 @@ pub mod test {
{ continue_chan: continue_chan };
let async_data_ptr = ptr::addr_of(&async_data);
let server_data: tcp_server_data = {
let server_data = tcp_server_data {
client: tcp_client_ptr,
server: tcp_server_ptr,
server_kill_msg: kill_server_msg,