Skip to content

Commit 3a59d30

Browse files
committed
---
yaml --- r: 150767 b: refs/heads/try2 c: 7240fad h: refs/heads/master i: 150765: 63a382d 150763: 22bb130 150759: 7492551 150751: 7ecff52 v: v3
1 parent dcd1c9b commit 3a59d30

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

86 files changed

+1002
-1263
lines changed

[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
55
refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
66
refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
77
refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
8-
refs/heads/try2: c48a3efb17f20453a44260411f87a6818cbcf8dd
8+
refs/heads/try2: 7240fad25e309ae5d8ebfb2b7544a1e62f9382fe
99
refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
1010
refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
1111
refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/main.mk

Lines changed: 32 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -349,21 +349,44 @@ EXTRAFLAGS_STAGE$(1) = $$(RUSTFLAGS_STAGE$(1))
349349

350350
CFGFLAG$(1)_T_$(2)_H_$(3) = stage$(1)
351351

352+
endef
353+
354+
# Same macro/variables as above, but defined in a separate loop so it can use
355+
# all the varibles above for all archs. The RPATH_VAR setup sometimes needs to
356+
# reach across triples to get things in order.
357+
define SREQ_CMDS
358+
359+
ifeq ($$(OSTYPE_$(3)),apple-darwin)
360+
RPATH_VAR$(1)_T_$(2)_H_$(3) := \
361+
DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
362+
else
363+
RPATH_VAR$(1)_T_$(2)_H_$(3) := \
364+
LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
365+
endif
366+
352367
# Pass --cfg stage0 only for the build->host part of stage0;
353368
# if you're building a cross config, the host->* parts are
354369
# effectively stage1, since it uses the just-built stage0.
370+
#
371+
# This logic is similar to how the LD_LIBRARY_PATH variable must
372+
# change be slightly different when doing cross compilations.
373+
# The build doesn't copy over all target libraries into
374+
# a new directory, so we need to point the library path at
375+
# the build directory where all the target libraries came
376+
# from (the stage0 build host). Otherwise the relative rpaths
377+
# inside of the rustc binary won't get resolved correctly.
355378
ifeq ($(1),0)
356379
ifneq ($(strip $(CFG_BUILD)),$(strip $(3)))
357380
CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
358-
endif
359-
endif
360381

361382
ifeq ($$(OSTYPE_$(3)),apple-darwin)
362383
RPATH_VAR$(1)_T_$(2)_H_$(3) := \
363-
DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
384+
DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))"
364385
else
365386
RPATH_VAR$(1)_T_$(2)_H_$(3) := \
366-
LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
387+
LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))"
388+
endif
389+
endif
367390
endif
368391

369392
STAGE$(1)_T_$(2)_H_$(3) := \
@@ -390,6 +413,11 @@ $(foreach build,$(CFG_HOST), \
390413
$(eval $(foreach stage,$(STAGES), \
391414
$(eval $(call SREQ,$(stage),$(target),$(build))))))))
392415

416+
$(foreach build,$(CFG_HOST), \
417+
$(eval $(foreach target,$(CFG_TARGET), \
418+
$(eval $(foreach stage,$(STAGES), \
419+
$(eval $(call SREQ_CMDS,$(stage),$(target),$(build))))))))
420+
393421
######################################################################
394422
# rustc-H-targets
395423
#

branches/try2/src/doc/guide-ffi.md

Lines changed: 58 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -11,14 +11,16 @@ snappy includes a C interface (documented in
1111
The following is a minimal example of calling a foreign function which will
1212
compile if snappy is installed:
1313

14-
~~~~ {.ignore}
14+
~~~~
1515
extern crate libc;
1616
use libc::size_t;
1717
1818
#[link(name = "snappy")]
19+
# #[cfg(ignore_this)]
1920
extern {
2021
fn snappy_max_compressed_length(source_length: size_t) -> size_t;
2122
}
23+
# unsafe fn snappy_max_compressed_length(a: size_t) -> size_t { a }
2224
2325
fn main() {
2426
let x = unsafe { snappy_max_compressed_length(100) };
@@ -78,7 +80,11 @@ vectors as pointers to memory. Rust's vectors are guaranteed to be a contiguous
7880
length is number of elements currently contained, and the capacity is the total size in elements of
7981
the allocated memory. The length is less than or equal to the capacity.
8082

81-
~~~~ {.ignore}
83+
~~~~
84+
# extern crate libc;
85+
# use libc::{c_int, size_t};
86+
# unsafe fn snappy_validate_compressed_buffer(_: *u8, _: size_t) -> c_int { 0 }
87+
# fn main() {}
8288
pub fn validate_compressed_buffer(src: &[u8]) -> bool {
8389
unsafe {
8490
snappy_validate_compressed_buffer(src.as_ptr(), src.len() as size_t) == 0
@@ -98,14 +104,20 @@ required capacity to hold the compressed output. The vector can then be passed t
98104
`snappy_compress` function as an output parameter. An output parameter is also passed to retrieve
99105
the true length after compression for setting the length.
100106

101-
~~~~ {.ignore}
102-
pub fn compress(src: &[u8]) -> ~[u8] {
107+
~~~~
108+
# extern crate libc;
109+
# use libc::{size_t, c_int};
110+
# unsafe fn snappy_compress(a: *u8, b: size_t, c: *mut u8,
111+
# d: *mut size_t) -> c_int { 0 }
112+
# unsafe fn snappy_max_compressed_length(a: size_t) -> size_t { a }
113+
# fn main() {}
114+
pub fn compress(src: &[u8]) -> Vec<u8> {
103115
unsafe {
104116
let srclen = src.len() as size_t;
105117
let psrc = src.as_ptr();
106118
107119
let mut dstlen = snappy_max_compressed_length(srclen);
108-
let mut dst = slice::with_capacity(dstlen as uint);
120+
let mut dst = Vec::with_capacity(dstlen as uint);
109121
let pdst = dst.as_mut_ptr();
110122
111123
snappy_compress(psrc, srclen, pdst, &mut dstlen);
@@ -118,16 +130,26 @@ pub fn compress(src: &[u8]) -> ~[u8] {
118130
Decompression is similar, because snappy stores the uncompressed size as part of the compression
119131
format and `snappy_uncompressed_length` will retrieve the exact buffer size required.
120132

121-
~~~~ {.ignore}
122-
pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
133+
~~~~
134+
# extern crate libc;
135+
# use libc::{size_t, c_int};
136+
# unsafe fn snappy_uncompress(compressed: *u8,
137+
# compressed_length: size_t,
138+
# uncompressed: *mut u8,
139+
# uncompressed_length: *mut size_t) -> c_int { 0 }
140+
# unsafe fn snappy_uncompressed_length(compressed: *u8,
141+
# compressed_length: size_t,
142+
# result: *mut size_t) -> c_int { 0 }
143+
# fn main() {}
144+
pub fn uncompress(src: &[u8]) -> Option<Vec<u8>> {
123145
unsafe {
124146
let srclen = src.len() as size_t;
125147
let psrc = src.as_ptr();
126148
127149
let mut dstlen: size_t = 0;
128150
snappy_uncompressed_length(psrc, srclen, &mut dstlen);
129151
130-
let mut dst = slice::with_capacity(dstlen as uint);
152+
let mut dst = Vec::with_capacity(dstlen as uint);
131153
let pdst = dst.as_mut_ptr();
132154
133155
if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {
@@ -187,16 +209,19 @@ A basic example is:
187209

188210
Rust code:
189211

190-
~~~~ {.ignore}
212+
~~~~
191213
extern fn callback(a:i32) {
192214
println!("I'm called from C with value {0}", a);
193215
}
194216
195217
#[link(name = "extlib")]
218+
# #[cfg(ignore)]
196219
extern {
197-
fn register_callback(cb: extern "C" fn(i32)) -> i32;
220+
fn register_callback(cb: extern fn(i32)) -> i32;
198221
fn trigger_callback();
199222
}
223+
# unsafe fn register_callback(cb: extern fn(i32)) -> i32 { 0 }
224+
# unsafe fn trigger_callback() { }
200225
201226
fn main() {
202227
unsafe {
@@ -240,33 +265,39 @@ referenced Rust object.
240265

241266
Rust code:
242267

243-
~~~~ {.ignore}
268+
~~~~
244269
245270
struct RustObject {
246271
a: i32,
247272
// other members
248273
}
249274
250-
extern fn callback(target: *RustObject, a:i32) {
275+
extern fn callback(target: *mut RustObject, a:i32) {
251276
println!("I'm called from C with value {0}", a);
252-
(*target).a = a; // Update the value in RustObject with the value received from the callback
277+
unsafe {
278+
// Update the value in RustObject with the value received from the callback
279+
(*target).a = a;
280+
}
253281
}
254282
255283
#[link(name = "extlib")]
284+
# #[cfg(ignore)]
256285
extern {
257-
fn register_callback(target: *RustObject, cb: extern "C" fn(*RustObject, i32)) -> i32;
286+
fn register_callback(target: *mut RustObject,
287+
cb: extern fn(*mut RustObject, i32)) -> i32;
258288
fn trigger_callback();
259289
}
290+
# unsafe fn register_callback(a: *mut RustObject,
291+
# b: extern fn(*mut RustObject, i32)) -> i32 { 0 }
292+
# unsafe fn trigger_callback() {}
260293
261294
fn main() {
262295
// Create the object that will be referenced in the callback
263-
let rust_object = ~RustObject{a: 5, ...};
296+
let mut rust_object = ~RustObject{ a: 5 };
264297
265298
unsafe {
266-
// Gets a raw pointer to the object
267-
let target_addr:*RustObject = ptr::to_unsafe_ptr(rust_object);
268-
register_callback(target_addr, callback);
269-
trigger_callback(); // Triggers the callback
299+
register_callback(&mut *rust_object, callback);
300+
trigger_callback();
270301
}
271302
}
272303
~~~~
@@ -403,13 +434,15 @@ Foreign APIs often export a global variable which could do something like track
403434
global state. In order to access these variables, you declare them in `extern`
404435
blocks with the `static` keyword:
405436

406-
~~~{.ignore}
437+
~~~
407438
extern crate libc;
408439
409440
#[link(name = "readline")]
441+
# #[cfg(ignore)]
410442
extern {
411443
static rl_readline_version: libc::c_int;
412444
}
445+
# static rl_readline_version: libc::c_int = 0;
413446
414447
fn main() {
415448
println!("You have readline version {} installed.",
@@ -421,21 +454,23 @@ Alternatively, you may need to alter global state provided by a foreign
421454
interface. To do this, statics can be declared with `mut` so rust can mutate
422455
them.
423456

424-
~~~{.ignore}
457+
~~~
425458
extern crate libc;
426459
use std::ptr;
427460
428461
#[link(name = "readline")]
462+
# #[cfg(ignore)]
429463
extern {
430464
static mut rl_prompt: *libc::c_char;
431465
}
466+
# static mut rl_prompt: *libc::c_char = 0 as *libc::c_char;
432467
433468
fn main() {
434-
do "[my-awesome-shell] $".as_c_str |buf| {
469+
"[my-awesome-shell] $".with_c_str(|buf| {
435470
unsafe { rl_prompt = buf; }
436471
// get a line, process it
437472
unsafe { rl_prompt = ptr::null(); }
438-
}
473+
});
439474
}
440475
~~~
441476

branches/try2/src/libgreen/sched.rs

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1011,7 +1011,6 @@ fn new_sched_rng() -> XorShiftRng {
10111011
mod test {
10121012
use rustuv;
10131013

1014-
use std::comm;
10151014
use std::task::TaskOpts;
10161015
use std::rt::task::Task;
10171016
use std::rt::local::Local;
@@ -1428,7 +1427,7 @@ mod test {
14281427
// This task should not be able to starve the sender;
14291428
// The sender should get stolen to another thread.
14301429
spawn(proc() {
1431-
while rx.try_recv() != comm::Data(()) { }
1430+
while rx.try_recv().is_err() { }
14321431
});
14331432

14341433
tx.send(());
@@ -1445,7 +1444,7 @@ mod test {
14451444
// This task should not be able to starve the other task.
14461445
// The sends should eventually yield.
14471446
spawn(proc() {
1448-
while rx1.try_recv() != comm::Data(()) {
1447+
while rx1.try_recv().is_err() {
14491448
tx2.send(());
14501449
}
14511450
});
@@ -1499,7 +1498,7 @@ mod test {
14991498
let mut val = 20;
15001499
while val > 0 {
15011500
val = po.recv();
1502-
ch.try_send(val - 1);
1501+
let _ = ch.send_opt(val - 1);
15031502
}
15041503
}
15051504

branches/try2/src/libgreen/task.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -515,7 +515,7 @@ mod tests {
515515
let _tx = tx;
516516
fail!()
517517
});
518-
assert_eq!(rx.recv_opt(), None);
518+
assert_eq!(rx.recv_opt(), Err(()));
519519
}
520520

521521
#[test]

branches/try2/src/liblog/lib.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -40,12 +40,12 @@ There are five macros that the logging subsystem uses:
4040
* `warn!(...)` - a macro hard-wired to the log level of `WARN`
4141
* `error!(...)` - a macro hard-wired to the log level of `ERROR`
4242
43-
All of these macros use std::the same style of syntax as the `format!` syntax
43+
All of these macros use the same style of syntax as the `format!` syntax
4444
extension. Details about the syntax can be found in the documentation of
4545
`std::fmt` along with the Rust tutorial/manual.
4646
4747
If you want to check at runtime if a given logging level is enabled (e.g. if the
48-
information you would want to log is expensive to produce), you can use std::the
48+
information you would want to log is expensive to produce), you can use the
4949
following macro:
5050
5151
* `log_enabled!(level)` - returns true if logging of the given level is enabled
@@ -63,7 +63,7 @@ path::to::module=log_level
6363
6464
The path to the module is rooted in the name of the crate it was compiled for,
6565
so if your program is contained in a file `hello.rs`, for example, to turn on
66-
logging for this file you would use std::a value of `RUST_LOG=hello`.
66+
logging for this file you would use a value of `RUST_LOG=hello`.
6767
Furthermore, this path is a prefix-search, so all modules nested in the
6868
specified module will also have logging enabled.
6969

branches/try2/src/libnative/io/mod.rs

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -55,11 +55,8 @@ pub mod file;
5555
#[cfg(target_os = "macos")]
5656
#[cfg(target_os = "freebsd")]
5757
#[cfg(target_os = "android")]
58-
#[path = "timer_other.rs"]
59-
pub mod timer;
60-
6158
#[cfg(target_os = "linux")]
62-
#[path = "timer_timerfd.rs"]
59+
#[path = "timer_unix.rs"]
6360
pub mod timer;
6461

6562
#[cfg(target_os = "win32")]

0 commit comments

Comments
 (0)