This is a rebase of my approved pull request from ... the end of June? It introduces hygiene for let-bound variables.
branch = master
[submodule "src/libuv"]
path = src/libuv
- url = https://github.com/brson/libuv.git
+ url = https://github.com/alexcrichton/libuv.git
branch = master
+[submodule "src/gyp"]
+ path = src/gyp
+ url = https://git.chromium.org/external/gyp.git
index2="${CFG_SRC_DIR}src/llvm/.git/index"
for index in ${index1} ${index2}
do
- config_status="${CFG_BUILD_DIR}llvm/$t/config.status"
+ config_status="${LLVM_BUILD_DIR}/config.status"
if test -e ${index} -a \
-e ${config_status} -a \
${config_status} -nt ${index}
PKG_EXE = $(PKG_DIR)-install.exe
endif
-PKG_GITMODULES := $(S)src/libuv $(S)src/llvm
+PKG_GITMODULES := $(S)src/libuv $(S)src/llvm $(S)src/gyp
PKG_FILES := \
$(S)COPYRIGHT \
$$(S)src/libuv/*/*/*/*)
endif
+LIBUV_MAKEFILE_$(1)_$(2) := $$(CFG_BUILD_DIR)$$(RT_BUILD_DIR_$(1)_$(2))/libuv/Makefile
+LIBUV_NO_LOAD = run-benchmarks.target.mk run-tests.target.mk \
+ uv_dtrace_header.target.mk uv_dtrace_provider.target.mk
+
+export PYTHONPATH := $(PYTHONPATH):$$(S)src/gyp/pylib
+
+$$(LIBUV_MAKEFILE_$(1)_$(2)):
+ (cd $(S)src/libuv/ && \
+ ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja \
+ -Goutput_dir=$$(@D) --generator-output $$(@D))
+
# XXX: Shouldn't need platform-specific conditions here
ifdef CFG_WINDOWSY_$(1)
$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
- $$(Q)$$(MAKE) -C $$(S)src/libuv/ \
- builddir_name="$$(CFG_BUILD_DIR)/$$(RT_BUILD_DIR_$(1)_$(2))/libuv" \
- OS=mingw \
+ $$(Q)$$(MAKE) -C $$(S)src/libuv -f Makefile.mingw \
+ CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
+ AR="$$(AR_$(1))" \
V=$$(VERBOSE)
+ $$(Q)cp $$(S)src/libuv/libuv.a $$@
else ifeq ($(OSTYPE_$(1)), linux-androideabi)
-$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
- $$(Q)$$(MAKE) -C $$(S)src/libuv/ \
+$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS) $$(LIBUV_MAKEFILE_$(1)_$(2))
+ $$(Q)$$(MAKE) -C $$(@D) \
CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1)))" \
CC="$$(CC_$(1))" \
LINK="$$(CXX_$(1))" \
AR="$$(AR_$(1))" \
PLATFORM=android \
- BUILDTYPE=Release \
- builddir_name="$$(CFG_BUILD_DIR)/$$(RT_BUILD_DIR_$(1)_$(2))/libuv" \
host=android OS=linux \
+ builddir="." \
+ BUILDTYPE=Release \
+ NO_LOAD="$$(LIBUV_NO_LOAD)" \
V=$$(VERBOSE)
else
-$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
- $$(Q)$$(MAKE) -C $$(S)src/libuv/ \
+$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS) $$(LIBUV_MAKEFILE_$(1)_$(2))
+ $$(Q)$$(MAKE) -C $$(@D) \
CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1)))" \
CC="$$(CC_$(1))" \
CXX="$$(CXX_$(1))" \
AR="$$(AR_$(1))" \
- builddir_name="$$(CFG_BUILD_DIR)/$$(RT_BUILD_DIR_$(1)_$(2))/libuv" \
+ builddir="." \
+ BUILDTYPE=Release \
+ NO_LOAD="$$(LIBUV_NO_LOAD)" \
V=$$(VERBOSE)
endif
--- /dev/null
+Subproject commit f407f09c94e00d2d570e8e42114e3f6848b2deb2
&& is_sep(prev_char.unwrap_or_default('/')))
};
- for ti in range(i, self.tokens.len()) {
- match self.tokens[ti] {
+ for (ti, token) in self.tokens.slice_from(i).iter().enumerate() {
+ match *token {
AnySequence => {
loop {
- match self.matches_from(prev_char, file, ti + 1, options) {
+ match self.matches_from(prev_char, file, i + ti + 1, options) {
SubPatternDoesntMatch => (), // keep trying
m => return m,
}
}
let (c, next) = file.slice_shift_char();
- let matches = match self.tokens[ti] {
+ let matches = match *token {
AnyChar => {
!require_literal(c)
}
Some((value, pos))
}
+ fn match_fractional_seconds(ss: &str, pos: uint) -> (i32, uint) {
+ let len = ss.len();
+ let mut value = 0_i32;
+ let mut multiplier = NSEC_PER_SEC / 10;
+ let mut pos = pos;
+
+ loop {
+ if pos >= len {
+ break;
+ }
+ let range = ss.char_range_at(pos);
+
+ match range.ch {
+ '0' .. '9' => {
+ pos = range.next;
+ // This will drop digits after the nanoseconds place
+ let digit = range.ch as i32 - '0' as i32;
+ value += digit * multiplier;
+ multiplier /= 10;
+ }
+ _ => break
+ }
+ }
+
+ (value, pos)
+ }
+
fn match_digits_in_range(ss: &str, pos: uint, digits: uint, ws: bool,
min: i32, max: i32) -> Option<(i32, uint)> {
match match_digits(ss, pos, digits, ws) {
Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) }
None => Err(~"Invalid day of the month")
},
+ 'f' => {
+ let (val, pos) = match_fractional_seconds(s, pos);
+ tm.tm_nsec = val;
+ Ok(pos)
+ }
'F' => {
parse_type(s, pos, 'Y', &mut *tm)
.chain(|pos| parse_char(s, pos, '-'))
}
'd' => fmt!("%02d", tm.tm_mday as int),
'e' => fmt!("%2d", tm.tm_mday as int),
+ 'f' => fmt!("%09d", tm.tm_nsec as int),
'F' => {
fmt!("%s-%s-%s",
parse_type('Y', tm),
Err(_) => ()
}
- let format = "%a %b %e %T %Y";
+ let format = "%a %b %e %T.%f %Y";
assert_eq!(strptime("", format), Err(~"Invalid time"));
assert!(strptime("Fri Feb 13 15:31:30", format)
== Err(~"Invalid time"));
- match strptime("Fri Feb 13 15:31:30 2009", format) {
+ match strptime("Fri Feb 13 15:31:30.01234 2009", format) {
Err(e) => fail!(e),
Ok(ref tm) => {
assert!(tm.tm_sec == 30_i32);
assert!(tm.tm_isdst == 0_i32);
assert!(tm.tm_gmtoff == 0_i32);
assert!(tm.tm_zone == ~"");
- assert!(tm.tm_nsec == 0_i32);
+ assert!(tm.tm_nsec == 12340000_i32);
}
}
assert_eq!(local.strftime("%D"), ~"02/13/09");
assert_eq!(local.strftime("%d"), ~"13");
assert_eq!(local.strftime("%e"), ~"13");
+ assert_eq!(local.strftime("%f"), ~"000054321");
assert_eq!(local.strftime("%F"), ~"2009-02-13");
// assert!(local.strftime("%G") == "2009");
// assert!(local.strftime("%g") == "09");
// Detect overflow by comparing to last value, except
// if we've not seen any non-zero digits.
if last_accum != _0 {
- if accum_positive && accum <= last_accum { return None; }
- if !accum_positive && accum >= last_accum { return None; }
+ if accum_positive && accum <= last_accum { return NumStrConv::inf(); }
+ if !accum_positive && accum >= last_accum { return NumStrConv::neg_inf(); }
+
+ // Detect overflow by reversing the shift-and-add proccess
+ if accum_positive &&
+ (last_accum != ((accum - cast(digit as int))/radix_gen.clone())) {
+ return NumStrConv::inf();
+ }
+ if !accum_positive &&
+ (last_accum != ((accum + cast(digit as int))/radix_gen.clone())) {
+ return NumStrConv::neg_inf();
+ }
}
last_accum = accum.clone();
}
}
// Detect overflow by comparing to last value
- if accum_positive && accum < last_accum { return None; }
- if !accum_positive && accum > last_accum { return None; }
+ if accum_positive && accum < last_accum { return NumStrConv::inf(); }
+ if !accum_positive && accum > last_accum { return NumStrConv::neg_inf(); }
last_accum = accum.clone();
}
None => match c {
ExpNone, false, false);
assert_eq!(n, None);
}
+
+ #[test]
+ fn from_str_issue7588() {
+ let u : Option<u8> = from_str_common("1000", 10, false, false, false,
+ ExpNone, false, false);
+ assert_eq!(u, None);
+ let s : Option<i16> = from_str_common("80000", 10, false, false, false,
+ ExpNone, false, false);
+ assert_eq!(s, None);
+ let f : Option<f32> = from_str_common(
+ "10000000000000000000000000000000000000000", 10, false, false, false,
+ ExpNone, false, false);
+ assert_eq!(f, NumStrConv::inf())
+ let fe : Option<f32> = from_str_common("1e40", 10, false, false, false,
+ ExpDec, false, false);
+ assert_eq!(fe, NumStrConv::inf())
+ }
}
#[cfg(test)]
do run_in_newsched_task {
let mut called = false;
do io_error::cond.trap(|e| {
- assert!(e.kind == ConnectionRefused);
+ assert_eq!(e.kind, ConnectionRefused);
called = true;
}).inside {
let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
use rt::uv::uvll;
use rt::uv::uvll::UV_GETADDRINFO;
use rt::uv::{Loop, UvError, NativeHandle};
-use rt::uv::status_to_maybe_uv_error_with_loop;
+use rt::uv::status_to_maybe_uv_error;
use rt::uv::net::UvAddrInfo;
type GetAddrInfoCallback = ~fn(GetAddrInfoRequest, &UvAddrInfo, Option<UvError>);
status: c_int,
res: *uvll::addrinfo) {
let mut req: GetAddrInfoRequest = NativeHandle::from_native_handle(req);
- let loop_ = req.get_loop();
- let err = status_to_maybe_uv_error_with_loop(loop_.native_handle(), status);
+ let err = status_to_maybe_uv_error(status);
let addrinfo = UvAddrInfo(res);
let data = req.get_req_data();
(*data.getaddrinfo_cb.get_ref())(req, &addrinfo, err);
extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) {
let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle);
- let status = status_to_maybe_uv_error(watcher, status);
+ let status = status_to_maybe_uv_error(status);
let data = watcher.get_watcher_data();
let cb = data.async_cb.get_ref();
(*cb)(watcher, status);
use ptr::null;
use libc::c_void;
use rt::uv::{Request, NativeHandle, Loop, FsCallback, Buf,
- status_to_maybe_uv_error_with_loop, UvError};
+ status_to_maybe_uv_error, UvError};
use rt::uv::uvll;
use rt::uv::uvll::*;
use super::super::io::support::PathLike;
pub fn open_sync<P: PathLike>(loop_: &Loop, path: &P, flags: int, mode: int)
-> Result<int, UvError> {
let result = FsRequest::open_common(loop_, path, flags, mode, None);
- sync_cleanup(loop_, result)
+ sync_cleanup(result)
}
fn unlink_common<P: PathLike>(loop_: &Loop, path: &P, cb: Option<FsCallback>) -> int {
}
pub fn unlink<P: PathLike>(loop_: &Loop, path: &P, cb: FsCallback) {
let result = FsRequest::unlink_common(loop_, path, Some(cb));
- sync_cleanup(loop_, result);
+ sync_cleanup(result);
}
pub fn unlink_sync<P: PathLike>(loop_: &Loop, path: &P) -> Result<int, UvError> {
let result = FsRequest::unlink_common(loop_, path, None);
- sync_cleanup(loop_, result)
+ sync_cleanup(result)
}
pub fn install_req_data(&self, cb: Option<FsCallback>) {
}
}
-fn sync_cleanup(loop_: &Loop, result: int)
+fn sync_cleanup(result: int)
-> Result<int, UvError> {
- match status_to_maybe_uv_error_with_loop(loop_.native_handle(), result as i32) {
+ match status_to_maybe_uv_error(result as i32) {
Some(err) => Err(err),
None => Ok(result)
}
pub fn write_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
-> Result<int, UvError> {
let result = self.write_common(loop_, buf, offset, None);
- sync_cleanup(loop_, result)
+ sync_cleanup(result)
}
fn read_common(&mut self, loop_: &Loop, buf: Buf,
pub fn read_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
-> Result<int, UvError> {
let result = self.read_common(loop_, buf, offset, None);
- sync_cleanup(loop_, result)
+ sync_cleanup(result)
}
fn close_common(self, loop_: &Loop, cb: Option<FsCallback>) -> int {
}
pub fn close_sync(self, loop_: &Loop) -> Result<int, UvError> {
let result = self.close_common(loop_, None);
- sync_cleanup(loop_, result)
+ sync_cleanup(result)
}
}
extern fn compl_cb(req: *uv_fs_t) {
let mut req: FsRequest = NativeHandle::from_native_handle(req);
- let loop_ = req.get_loop();
// pull the user cb out of the req data
let cb = {
let data = req.get_req_data();
// in uv_fs_open calls, the result will be the fd in the
// case of success, otherwise it's -1 indicating an error
let result = req.get_result();
- let status = status_to_maybe_uv_error_with_loop(
- loop_.native_handle(), result);
+ let status = status_to_maybe_uv_error(result);
// we have a req and status, call the user cb..
// only giving the user a ref to the FsRequest, as we
// have to clean it up, afterwards (and they aren't really
let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
let data = idle_watcher.get_watcher_data();
let cb: &IdleCallback = data.idle_cb.get_ref();
- let status = status_to_maybe_uv_error(idle_watcher, status);
+ let status = status_to_maybe_uv_error(status);
(*cb)(idle_watcher, status);
}
}
let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
let data = idle_watcher.get_watcher_data();
let cb: &IdleCallback = data.idle_cb.get_ref();
- let status = status_to_maybe_uv_error(idle_watcher, status);
+ let status = status_to_maybe_uv_error(status);
(*cb)(idle_watcher, status);
}
}
// XXX: Need to define the error constants like EOF so they can be
// compared to the UvError type
-pub struct UvError(uvll::uv_err_t);
+pub struct UvError(c_int);
impl UvError {
pub fn name(&self) -> ~str {
unsafe {
- let inner = match self { &UvError(ref a) => a };
+ let inner = match self { &UvError(a) => a };
let name_str = uvll::err_name(inner);
assert!(name_str.is_not_null());
from_c_str(name_str)
pub fn desc(&self) -> ~str {
unsafe {
- let inner = match self { &UvError(ref a) => a };
+ let inner = match self { &UvError(a) => a };
let desc_str = uvll::strerror(inner);
assert!(desc_str.is_not_null());
from_c_str(desc_str)
}
pub fn is_eof(&self) -> bool {
- self.code == uvll::EOF
+ **self == uvll::EOF
}
}
#[test]
fn error_smoke_test() {
- let err = uvll::uv_err_t { code: 1, sys_errno_: 1 };
- let err: UvError = UvError(err);
+ let err: UvError = UvError(uvll::EOF);
assert_eq!(err.to_str(), ~"EOF: end of file");
}
-pub fn last_uv_error<H, W: Watcher + NativeHandle<*H>>(watcher: &W) -> UvError {
- unsafe {
- let loop_ = watcher.event_loop();
- UvError(uvll::last_error(loop_.native_handle()))
- }
-}
-
pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
unsafe {
// Importing error constants
use rt::io::*;
// uv error descriptions are static
- let c_desc = uvll::strerror(&*uverr);
+ let c_desc = uvll::strerror(*uverr);
let desc = str::raw::c_str_to_static_slice(c_desc);
- let kind = match uverr.code {
+ let kind = match *uverr {
UNKNOWN => OtherIoError,
OK => OtherIoError,
EOF => EndOfFile,
ECONNREFUSED => ConnectionRefused,
ECONNRESET => ConnectionReset,
EPIPE => BrokenPipe,
- _ => {
- rtdebug!("uverr.code %u", uverr.code as uint);
+ err => {
+ rtdebug!("uverr.code %d", err as int);
// XXX: Need to map remaining uv error types
OtherIoError
}
}
/// Given a uv handle, convert a callback status to a UvError
-pub fn status_to_maybe_uv_error_with_loop(
- loop_: *uvll::uv_loop_t,
- status: c_int) -> Option<UvError> {
- if status != -1 {
+pub fn status_to_maybe_uv_error(status: c_int) -> Option<UvError>
+{
+ if status >= 0 {
None
} else {
- unsafe {
- rtdebug!("loop: %x", loop_ as uint);
- let err = uvll::last_error(loop_);
- Some(UvError(err))
- }
- }
-}
-/// Given a uv handle, convert a callback status to a UvError
-pub fn status_to_maybe_uv_error<T, U: Watcher + NativeHandle<*T>>(handle: U,
- status: c_int) -> Option<UvError> {
- if status != -1 {
- None
- } else {
- unsafe {
- rtdebug!("handle: %x", handle.native_handle() as uint);
- let loop_ = uvll::get_loop_for_uv_handle(handle.native_handle());
- status_to_maybe_uv_error_with_loop(loop_, status)
- }
+ Some(UvError(status))
}
}
use rt::uv::{Loop, Watcher, Request, UvError, Buf, NativeHandle, NullCallback,
status_to_maybe_uv_error};
use rt::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
-use rt::uv::last_uv_error;
use vec;
use str;
use from_str::{FromStr};
rtdebug!("buf len: %d", buf.len as int);
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream);
let cb = stream_watcher.get_watcher_data().read_cb.get_ref();
- let status = status_to_maybe_uv_error(stream_watcher, nread as c_int);
+ let status = status_to_maybe_uv_error(nread as c_int);
(*cb)(stream_watcher, nread as int, buf, status);
}
}
let mut stream_watcher = write_request.stream();
write_request.delete();
let cb = stream_watcher.get_watcher_data().write_cb.take_unwrap();
- let status = status_to_maybe_uv_error(stream_watcher, status);
+ let status = status_to_maybe_uv_error(status);
cb(stream_watcher, status);
}
}
};
match result {
0 => Ok(()),
- _ => Err(last_uv_error(self)),
+ _ => Err(UvError(result)),
}
}
}
let mut stream_watcher = connect_request.stream();
connect_request.delete();
let cb = stream_watcher.get_watcher_data().connect_cb.take_unwrap();
- let status = status_to_maybe_uv_error(stream_watcher, status);
+ let status = status_to_maybe_uv_error(status);
cb(stream_watcher, status);
}
}
rtdebug!("connection_cb");
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
let cb = stream_watcher.get_watcher_data().connect_cb.get_ref();
- let status = status_to_maybe_uv_error(stream_watcher, status);
+ let status = status_to_maybe_uv_error(status);
(*cb)(stream_watcher, status);
}
}
};
match result {
0 => Ok(()),
- _ => Err(last_uv_error(self)),
+ _ => Err(UvError(result)),
}
}
}
rtdebug!("buf len: %d", buf.len as int);
let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle);
let cb = udp_watcher.get_watcher_data().udp_recv_cb.get_ref();
- let status = status_to_maybe_uv_error(udp_watcher, nread as c_int);
+ let status = status_to_maybe_uv_error(nread as c_int);
let addr = uv_socket_addr_to_socket_addr(sockaddr_to_UvSocketAddr(addr));
(*cb)(udp_watcher, nread as int, buf, addr, flags as uint, status);
}
let mut udp_watcher = send_request.handle();
send_request.delete();
let cb = udp_watcher.get_watcher_data().udp_send_cb.take_unwrap();
- let status = status_to_maybe_uv_error(udp_watcher, status);
+ let status = status_to_maybe_uv_error(status);
cb(udp_watcher, status);
}
}
let mut watcher: TimerWatcher = NativeHandle::from_native_handle(handle);
let data = watcher.get_watcher_data();
let cb = data.timer_cb.get_ref();
- let status = status_to_maybe_uv_error(watcher, status);
+ let status = status_to_maybe_uv_error(status);
(*cb)(watcher, status);
}
}
};
if r != 0 {
- let status = status_to_maybe_uv_error(handle, r);
+ let status = status_to_maybe_uv_error(r);
return Err(uv_error_to_io_error(status.unwrap()));
}
uvll::tcp_simultaneous_accepts(self_.listener.watcher.native_handle(), 1 as c_int)
};
- match status_to_maybe_uv_error(self_.listener.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::tcp_simultaneous_accepts(self_.listener.watcher.native_handle(), 0 as c_int)
};
- match status_to_maybe_uv_error(self_.listener.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
do self.home_for_io |self_| {
let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 0 as c_int) };
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
do self.home_for_io |self_| {
let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 1 as c_int) };
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
delay_in_seconds as c_uint)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::tcp_keepalive(self_.watcher.native_handle(), 0 as c_int, 0 as c_uint)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
}
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
}
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 1 as c_int)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 0 as c_int)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::udp_set_multicast_ttl(self_.watcher.native_handle(), ttl as c_int)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::udp_set_ttl(self_.watcher.native_handle(), ttl as c_int)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::udp_set_broadcast(self_.watcher.native_handle(), 1 as c_int)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
uvll::udp_set_broadcast(self_.watcher.native_handle(), 0 as c_int)
};
- match status_to_maybe_uv_error(self_.watcher, r) {
+ match status_to_maybe_uv_error(r) {
Some(err) => Err(uv_error_to_io_error(err)),
None => Ok(())
}
use libc;
use prelude::*;
use ptr;
-use str;
use vec;
-pub static UNKNOWN: c_int = -1;
+pub use self::errors::*;
+
pub static OK: c_int = 0;
-pub static EOF: c_int = 1;
-pub static EADDRINFO: c_int = 2;
-pub static EACCES: c_int = 3;
-pub static ECONNREFUSED: c_int = 12;
-pub static ECONNRESET: c_int = 13;
-pub static EPIPE: c_int = 36;
+pub static EOF: c_int = -4095;
+pub static UNKNOWN: c_int = -4094;
+
+// uv-errno.h redefines error codes for windows, but not for unix...
+
+#[cfg(windows)]
+pub mod errors {
+ use libc::c_int;
-pub struct uv_err_t {
- code: c_int,
- sys_errno_: c_int
+ pub static EACCES: c_int = -4093;
+ pub static ECONNREFUSED: c_int = -4079;
+ pub static ECONNRESET: c_int = -4078;
+ pub static EPIPE: c_int = -4048;
+}
+#[cfg(not(windows))]
+pub mod errors {
+ use libc;
+ use libc::c_int;
+
+ pub static EACCES: c_int = -libc::EACCES;
+ pub static ECONNREFUSED: c_int = -libc::ECONNREFUSED;
+ pub static ECONNRESET: c_int = -libc::ECONNRESET;
+ pub static EPIPE: c_int = -libc::EPIPE;
}
pub struct uv_buf_t {
return rust_uv_read_stop(stream as *c_void);
}
-pub unsafe fn last_error(loop_handle: *c_void) -> uv_err_t {
- #[fixed_stack_segment]; #[inline(never)];
-
- return rust_uv_last_error(loop_handle);
-}
-
-pub unsafe fn strerror(err: *uv_err_t) -> *c_char {
+pub unsafe fn strerror(err: c_int) -> *c_char {
#[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_strerror(err);
}
-pub unsafe fn err_name(err: *uv_err_t) -> *c_char {
+pub unsafe fn err_name(err: c_int) -> *c_char {
#[fixed_stack_segment]; #[inline(never)];
-
return rust_uv_err_name(err);
}
rust_uv_freeaddrinfo(ai);
}
-pub unsafe fn get_last_err_info(uv_loop: *c_void) -> ~str {
- let err = last_error(uv_loop);
- let err_ptr = ptr::to_unsafe_ptr(&err);
- let err_name = str::raw::from_c_str(err_name(err_ptr));
- let err_msg = str::raw::from_c_str(strerror(err_ptr));
- return fmt!("LIBUV ERROR: name: %s msg: %s",
- err_name, err_msg);
-}
-
-pub unsafe fn get_last_err_data(uv_loop: *c_void) -> uv_err_data {
- let err = last_error(uv_loop);
- let err_ptr = ptr::to_unsafe_ptr(&err);
- let err_name = str::raw::from_c_str(err_name(err_ptr));
- let err_msg = str::raw::from_c_str(strerror(err_ptr));
- uv_err_data { err_name: err_name, err_msg: err_msg }
-}
-
pub struct uv_err_data {
err_name: ~str,
err_msg: ~str,
cb: uv_async_cb) -> c_int;
fn rust_uv_tcp_init(loop_handle: *c_void, handle_ptr: *uv_tcp_t) -> c_int;
fn rust_uv_buf_init(out_buf: *uv_buf_t, base: *u8, len: size_t);
- fn rust_uv_last_error(loop_handle: *c_void) -> uv_err_t;
- fn rust_uv_strerror(err: *uv_err_t) -> *c_char;
- fn rust_uv_err_name(err: *uv_err_t) -> *c_char;
+ fn rust_uv_strerror(err: c_int) -> *c_char;
+ fn rust_uv_err_name(err: c_int) -> *c_char;
fn rust_uv_ip4_addrp(ip: *u8, port: c_int) -> *sockaddr_in;
fn rust_uv_ip6_addrp(ip: *u8, port: c_int) -> *sockaddr_in6;
fn rust_uv_free_ip4_addr(addr: *sockaddr_in);
-Subproject commit dfae9c3e958dc086d9c0ab068cd76d196c95a433
+Subproject commit d88cf5652a1afb23939da0bae86c70ec521b9921
return buf.len;
}
-extern "C" uv_err_t
-rust_uv_last_error(uv_loop_t* loop) {
- return uv_last_error(loop);
-}
-
extern "C" const char*
-rust_uv_strerror(uv_err_t* err_ptr) {
- uv_err_t err = *err_ptr;
+rust_uv_strerror(int err) {
return uv_strerror(err);
}
extern "C" const char*
-rust_uv_err_name(uv_err_t* err_ptr) {
- uv_err_t err = *err_ptr;
+rust_uv_err_name(int err) {
return uv_err_name(err);
}
rust_uv_timer_stop
rust_uv_tcp_init
rust_uv_buf_init
-rust_uv_last_error
rust_uv_strerror
rust_uv_err_name
rust_uv_ip4_addr
projects / rust.git / commitdiff