experimenting with a different uv_buf_init impl to placate 32bit linux

src/libstd/uv.rs

@@ -66,10 +66,6 @@ native mod rustrt {
     fn rust_uv_tcp_init(
         loop_handle: *libc::c_void,
         handle_ptr: *ll::uv_tcp_t) -> libc::c_int;
-    fn rust_uv_buf_init(base: *u8, len: libc::size_t)
-        -> ll::uv_buf_t;
-    fn rust_uv_last_error(loop_handle: *libc::c_void) ->
-        ll::uv_err_t;
     // FIXME ref #2064
     fn rust_uv_strerror(err: *ll::uv_err_t) -> *libc::c_char;
     // FIXME ref #2064
@@ -723,6 +719,9 @@ crust fn on_alloc_cb(handle: *libc::c_void,
     -> ll::uv_buf_t unsafe {
     io::println("on_alloc_cb!");
     let char_ptr = ll::malloc_buf_base_of(suggested_size);
+    io::println(#fmt("on_alloc_cb char_ptr: %u sug. size: %u",
+                     char_ptr as uint,
+                     suggested_size as uint));
     ret ll::buf_init(char_ptr, suggested_size);
 }
 
@@ -816,6 +815,7 @@ fn impl_uv_tcp_request(ip: str, port: int, req_str: str,
     // data field in our uv_connect_t struct
     let req_str_bytes = str::bytes(req_str);
     let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes);
+    io::println(#fmt("req_msg ptr: %u", req_msg_ptr as uint));
     let req_msg = [
         ll::buf_init(req_msg_ptr, vec::len(req_str_bytes))
     ];
@@ -1051,6 +1051,7 @@ fn impl_uv_tcp_server(server_ip: str,
 
     let resp_str_bytes = str::bytes(server_resp_msg);
     let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes);
+    io::println(#fmt("resp_msg ptr: %u", resp_msg_ptr as uint));
     let resp_msg = [
         ll::buf_init(resp_msg_ptr, vec::len(resp_str_bytes))
     ];

src/libstd/uv_ll.rs

@@ -439,7 +439,10 @@ native mod rustrt {
     fn rust_uv_tcp_init(
         loop_handle: *libc::c_void,
         handle_ptr: *uv_tcp_t) -> libc::c_int;
-    fn rust_uv_buf_init(base: *u8, len: libc::size_t)
+    // FIXME ref #2604 .. ?
+    fn rust_uv_buf_init(out_buf: *uv_buf_t, base: *u8,
+                        len: libc::size_t);
+    fn rust_uv_buf_init_2(++base: *u8, len: libc::size_t)
         -> uv_buf_t;
     fn rust_uv_last_error(loop_handle: *libc::c_void) -> uv_err_t;
     // FIXME ref #2064
@@ -626,8 +629,25 @@ unsafe fn get_base_from_buf(buf: uv_buf_t) -> *u8 {
 unsafe fn get_len_from_buf(buf: uv_buf_t) -> libc::size_t {
     ret rustrt::rust_uv_get_len_from_buf(buf);
 }
-unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t {
-    ret rustrt::rust_uv_buf_init(input, len);
+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_ptr = ptr::addr_of(out_buf);
+    io::println(#fmt("ll::buf_init - input %u len %u out_buf: %u",
+                     input as uint,
+                     len as uint,
+                     out_buf_ptr as uint));
+    // yuck :/
+    rustrt::rust_uv_buf_init(out_buf_ptr, input, len);
+    //let result = rustrt::rust_uv_buf_init_2(input, len);
+    io::println("after rust_uv_buf_init");
+    let res_base = get_base_from_buf(out_buf);
+    let res_len = get_len_from_buf(out_buf);
+    //let res_base = get_base_from_buf(result);
+    io::println(#fmt("ll::buf_init - result %u len %u",
+                     res_base as uint,
+                     res_len as uint));
+    ret out_buf;
+    //ret result;
 }
 unsafe fn ip4_addr(ip: str, port: int)
 -> sockaddr_in {

src/rt/rust_uv.cpp

@@ -300,9 +300,24 @@ current_kernel_malloc_alloc_cb(uv_handle_t* handle,
     return uv_buf_init(base_ptr, suggested_size);
 }
 
+extern "C" void
+rust_uv_buf_init(uv_buf_t* out_buf, char* base, size_t len) {
+  printf("rust_uv_buf_init: base: %lu len: %lu\n",
+		 (long unsigned int)base,
+		 (long unsigned int)len);
+    *out_buf = uv_buf_init(base, len);
+    printf("rust_uv_buf_init: after: result->base: %lu len: %lu\n",
+		   (unsigned long int)(*out_buf).base,
+		   (unsigned long int)(*out_buf).len);
+}
 extern "C" uv_buf_t
-rust_uv_buf_init(char* base, size_t len) {
-    return uv_buf_init(base, len);
+rust_uv_buf_init_2(char* base, size_t len) {
+  printf("uv_buf_init: base ptr %p\n len: %lu", base,
+		 (long unsigned int)len);
+    uv_buf_t result = uv_buf_init(base, len);
+    printf("after uv_buf_init: result->base %p\n",
+		   result.base);
+	return result;
 }
 
 extern "C" uv_loop_t*