From 753b683939f41039ffefe98959faca8dc718c726 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Wed, 25 Apr 2012 17:18:06 -0700 Subject: [PATCH] More slice use in vec, io, str, ebml, metadata encoder and decoder. --- src/libcore/io.rs | 162 ++++++++++++++++++-------- src/libcore/str.rs | 12 ++ src/libcore/vec.rs | 49 +++++--- src/libstd/ebml.rs | 55 +++++---- src/rustc/metadata/encoder.rs | 6 +- src/rustc/metadata/tyencode.rs | 52 ++++----- src/test/bench/shootout-mandelbrot.rs | 2 +- 7 files changed, 220 insertions(+), 118 deletions(-) diff --git a/src/libcore/io.rs b/src/libcore/io.rs index b44ec02c74b3..0c723fc8c63a 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -297,23 +297,22 @@ enum fileflag { append, create, truncate, no_flag, } // FIXME: eventually u64 // #2004 iface writer { - fn write([const u8]); + fn write([const u8]/&); fn seek(int, seek_style); fn tell() -> uint; fn flush() -> int; } impl of writer for {base: T, cleanup: C} { - fn write(bs: [const u8]) { self.base.write(bs); } + fn write(bs: [const u8]/&) { self.base.write(bs); } fn seek(off: int, style: seek_style) { self.base.seek(off, style); } fn tell() -> uint { self.base.tell() } fn flush() -> int { self.base.flush() } } impl of writer for *libc::FILE { - fn write(v: [const u8]) unsafe { - let len = vec::len(v); - vec::as_buf(v) {|vbuf| + fn write(v: [const u8]/&) unsafe { + vec::unpack_slice(v) {|vbuf, len| let nout = libc::fwrite(vbuf as *c_void, len, 1u, self); if nout < 1 as size_t { #error("error writing buffer"); @@ -339,10 +338,9 @@ fn FILE_writer(f: *libc::FILE, cleanup: bool) -> writer { } impl of writer for fd_t { - fn write(v: [const u8]) unsafe { - let len = vec::len(v); + fn write(v: [const u8]/&) unsafe { let mut count = 0u; - vec::as_buf(v) {|vbuf| + vec::unpack_slice(v) {|vbuf, len| while count < len { let vb = ptr::offset(vbuf, count) as *c_void; let nout = libc::write(self, vb, len); @@ -408,26 +406,66 @@ fn mk_file_writer(path: str, flags: [fileflag]) } } -fn u64_to_le_bytes(n: u64, size: uint) -> [u8] { - let mut bytes: [u8] = [], i = size, n = n; - while i > 0u { - bytes += [(n & 255_u64) as u8]; - n >>= 8_u64; - i -= 1u; +fn u64_to_le_bytes(n: u64, size: uint, f: fn([u8]/&) -> T) -> T { + assert size <= 8u; + alt size { + 1u { f([n as u8]/&) } + 2u { f([n as u8, + (n >> 8) as u8]/&) } + 4u { f([n as u8, + (n >> 8) as u8, + (n >> 16) as u8, + (n >> 24) as u8]/&) } + 8u { f([n as u8, + (n >> 8) as u8, + (n >> 16) as u8, + (n >> 24) as u8, + (n >> 32) as u8, + (n >> 40) as u8, + (n >> 48) as u8, + (n >> 56) as u8]/&) } + _ { + + let mut bytes: [u8] = [], i = size, n = n; + while i > 0u { + bytes += [(n & 255_u64) as u8]; + n >>= 8_u64; + i -= 1u; + } + f(bytes) + } } - ret bytes; } -fn u64_to_be_bytes(n: u64, size: uint) -> [u8] { +fn u64_to_be_bytes(n: u64, size: uint, f: fn([u8]/&) -> T) -> T { assert size <= 8u; - let mut bytes: [u8] = []; - let mut i = size; - while i > 0u { - let shift = ((i - 1u) * 8u) as u64; - bytes += [(n >> shift) as u8]; - i -= 1u; + alt size { + 1u { f([n as u8]/&) } + 2u { f([(n >> 8) as u8, + n as u8]/&) } + 4u { f([(n >> 24) as u8, + (n >> 16) as u8, + (n >> 8) as u8, + n as u8]/&) } + 8u { f([(n >> 56) as u8, + (n >> 48) as u8, + (n >> 40) as u8, + (n >> 32) as u8, + (n >> 24) as u8, + (n >> 16) as u8, + (n >> 8) as u8, + n as u8]/&) } + _ { + let mut bytes: [u8] = []; + let mut i = size; + while i > 0u { + let shift = ((i - 1u) * 8u) as u64; + bytes += [(n >> shift) as u8]; + i -= 1u; + } + f(bytes) + } } - ret bytes; } fn u64_from_be_bytes(data: [u8], start: uint, size: uint) -> u64 { @@ -448,45 +486,67 @@ impl writer_util for writer { if ch as uint < 128u { self.write([ch as u8]); } else { - self.write(str::bytes(str::from_char(ch))); + self.write_str(str::from_char(ch)); } } - fn write_str(s: str) { self.write(str::bytes(s)); } - fn write_line(s: str) { self.write(str::bytes(s + "\n")); } - fn write_int(n: int) { self.write(str::bytes(int::to_str(n, 10u))); } - fn write_uint(n: uint) { self.write(str::bytes(uint::to_str(n, 10u))); } + fn write_str(s: str/&) { str::byte_slice(s) {|v| self.write(v); } } + fn write_line(s: str/&) { + self.write_str(s); + self.write_str("\n"/&); + } + fn write_int(n: int) { self.write_str(int::to_str(n, 10u)); } + fn write_uint(n: uint) { self.write_str(uint::to_str(n, 10u)); } fn write_le_uint(n: uint, size: uint) { - self.write(u64_to_le_bytes(n as u64, size)); + u64_to_le_bytes(n as u64, size) {|v| self.write(v); } } fn write_le_int(n: int, size: uint) { - self.write(u64_to_le_bytes(n as u64, size)); + u64_to_le_bytes(n as u64, size) {|v| self.write(v); } } - fn write_be_uint(n: uint, size: uint) { - self.write(u64_to_be_bytes(n as u64, size)); + u64_to_be_bytes(n as u64, size) {|v| self.write(v); } } fn write_be_int(n: int, size: uint) { - self.write(u64_to_be_bytes(n as u64, size)); + u64_to_be_bytes(n as u64, size) {|v| self.write(v); } + } + fn write_be_u64(n: u64) { + u64_to_be_bytes(n, 8u) {|v| self.write(v); } + } + fn write_be_u32(n: u32) { + u64_to_be_bytes(n as u64, 4u) {|v| self.write(v); } + } + fn write_be_u16(n: u16) { + u64_to_be_bytes(n as u64, 2u) {|v| self.write(v); } + } + fn write_be_i64(n: i64) { + u64_to_be_bytes(n as u64, 8u) {|v| self.write(v); } + } + fn write_be_i32(n: i32) { + u64_to_be_bytes(n as u64, 4u) {|v| self.write(v); } + } + fn write_be_i16(n: i16) { + u64_to_be_bytes(n as u64, 2u) {|v| self.write(v); } + } + fn write_le_u64(n: u64) { + u64_to_le_bytes(n, 8u) {|v| self.write(v); } + } + fn write_le_u32(n: u32) { + u64_to_le_bytes(n as u64, 4u) {|v| self.write(v); } + } + fn write_le_u16(n: u16) { + u64_to_le_bytes(n as u64, 2u) {|v| self.write(v); } + } + fn write_le_i64(n: i64) { + u64_to_le_bytes(n as u64, 8u) {|v| self.write(v); } + } + fn write_le_i32(n: i32) { + u64_to_le_bytes(n as u64, 4u) {|v| self.write(v); } + } + fn write_le_i16(n: i16) { + u64_to_le_bytes(n as u64, 2u) {|v| self.write(v); } } - fn write_be_u64(n: u64) { self.write(u64_to_be_bytes(n, 8u)); } - fn write_be_u32(n: u32) { self.write(u64_to_be_bytes(n as u64, 4u)); } - fn write_be_u16(n: u16) { self.write(u64_to_be_bytes(n as u64, 2u)); } - - fn write_be_i64(n: i64) { self.write(u64_to_be_bytes(n as u64, 8u)); } - fn write_be_i32(n: i32) { self.write(u64_to_be_bytes(n as u64, 4u)); } - fn write_be_i16(n: i16) { self.write(u64_to_be_bytes(n as u64, 2u)); } - - fn write_le_u64(n: u64) { self.write(u64_to_le_bytes(n, 8u)); } - fn write_le_u32(n: u32) { self.write(u64_to_le_bytes(n as u64, 4u)); } - fn write_le_u16(n: u16) { self.write(u64_to_le_bytes(n as u64, 2u)); } - - fn write_le_i64(n: i64) { self.write(u64_to_le_bytes(n as u64, 8u)); } - fn write_le_i32(n: i32) { self.write(u64_to_le_bytes(n as u64, 4u)); } - fn write_le_i16(n: i16) { self.write(u64_to_le_bytes(n as u64, 2u)); } - - fn write_u8(n: u8) { self.write([n]) } + fn write_u8(n: u8) { self.write([n]/&) } } fn file_writer(path: str, flags: [fileflag]) -> result { @@ -518,7 +578,7 @@ type mem_buffer = @{mut buf: [mut u8], mut pos: uint}; impl of writer for mem_buffer { - fn write(v: [const u8]) { + fn write(v: [const u8]/&) { // Fast path. if self.pos == vec::len(self.buf) { for vec::each(v) {|b| self.buf += [mut b]; } diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 03bb8f70dee2..12258f5eb274 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -33,6 +33,7 @@ export // Transforming strings bytes, + byte_slice, chars, substr, slice, @@ -323,6 +324,16 @@ fn bytes(s: str) -> [u8] unsafe { ret v; } +#[doc = " +Work with the string as a byte slice, not including trailing null. +"] +#[inline(always)] +fn byte_slice(s: str/&, f: fn([u8]/&) -> T) -> T unsafe { + unpack_slice(s) {|p,n| + vec::unsafe::form_slice(p, n-1u, f) + } +} + #[doc = "Convert a string to a vector of characters"] fn chars(s: str) -> [char] { let mut buf = [], i = 0u; @@ -1549,6 +1560,7 @@ length of the string. This is to permit probing the byte past the indexable area for a null byte, as is the case in slices pointing to full strings, or suffixes of them. "] +#[inline(always)] fn unpack_slice(s: str/&, f: fn(*u8, uint) -> T) -> T unsafe { let v : *(*u8,uint) = ::unsafe::reinterpret_cast(ptr::addr_of(s)); let (buf,len) = *v; diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 31f216763313..191012e51560 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -150,9 +150,8 @@ fn capacity(&&v: [const T]) -> uint unsafe { #[doc = "Returns the length of a vector"] #[inline(always)] -pure fn len(&&v: [const T]) -> uint unsafe { - let repr: **unsafe::vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); - (**repr).fill / sys::size_of::() +pure fn len(&&v: [const T]/&) -> uint unsafe { + unpack_slice(v) {|_p, len| len} } #[doc = " @@ -823,13 +822,15 @@ fn iter_between(v: [const T], start: uint, end: uint, f: fn(T)) { Iterates over a vector, with option to break "] #[inline(always)] -fn each(v: [const T], f: fn(T) -> bool) unsafe { - let mut n = len(v); - let mut p = ptr::offset(unsafe::to_ptr(v), 0u); - while n > 0u { - if !f(*p) { break; } - p = ptr::offset(p, 1u); - n -= 1u; +fn each(v: [const T]/&, f: fn(T) -> bool) unsafe { + vec::unpack_slice(v) {|p, n| + let mut n = n; + let mut p = p; + while n > 0u { + if !f(*p) { break; } + p = ptr::offset(p, 1u); + n -= 1u; + } } } @@ -837,13 +838,15 @@ fn each(v: [const T], f: fn(T) -> bool) unsafe { Iterates over a vector's elements and indices "] #[inline(always)] -fn eachi(v: [const T], f: fn(uint, T) -> bool) unsafe { - let mut i = 0u, l = len(v); - let mut p = ptr::offset(unsafe::to_ptr(v), 0u); - while i < l { - if !f(i, *p) { break; } - p = ptr::offset(p, 1u); - i += 1u; +fn eachi(v: [const T]/&, f: fn(uint, T) -> bool) unsafe { + vec::unpack_slice(v) {|p, n| + let mut i = 0u; + let mut p = p; + while i < n { + if !f(i, *p) { break; } + p = ptr::offset(p, 1u); + i += 1u; + } } } @@ -958,6 +961,7 @@ fn as_mut_buf(v: [mut E], f: fn(*mut E) -> T) -> T unsafe { #[doc = " Work with the buffer and length of a slice. "] +#[inline(always)] fn unpack_slice(s: [const T]/&, f: fn(*T, uint) -> U) -> U unsafe { let v : *(*T,uint) = ::unsafe::reinterpret_cast(ptr::addr_of(s)); let (buf,len) = *v; @@ -1191,6 +1195,17 @@ mod unsafe { let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); ret ::unsafe::reinterpret_cast(addr_of((**repr).data)); } + + + #[doc = " + Form a slice from a pointer and length (as a number of units, not bytes). + "] + #[inline(always)] + unsafe fn form_slice(p: *T, len: uint, f: fn([T]/&) -> U) -> U { + let pair = (p, len * sys::size_of::()); + let v : *([T]/&) = ::unsafe::reinterpret_cast(ptr::addr_of(pair)); + f(*v) + } } #[doc = "Operations on `[u8]`"] diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 91a9c244011e..ba7064bd5c46 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -39,7 +39,7 @@ type doc = {data: @[u8], start: uint, end: uint}; type tagged_doc = {tag: uint, doc: doc}; -fn vuint_at(data: [u8], start: uint) -> {val: uint, next: uint} { +fn vuint_at(data: [u8]/&, start: uint) -> {val: uint, next: uint} { let a = data[start]; if a & 0x80u8 != 0u8 { ret {val: (a & 0x7fu8) as uint, next: start + 1u}; @@ -152,20 +152,23 @@ fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 } type writer = {writer: io::writer, mut size_positions: [uint]}; fn write_sized_vuint(w: io::writer, n: uint, size: uint) { - let buf: [u8] = alt size { - 1u { [0x80u8 | (n as u8)] } - 2u { [0x40u8 | ((n >> 8_u) as u8), n as u8] } + alt size { + 1u { + w.write([0x80u8 | (n as u8)]/&); + } + 2u { + w.write([0x40u8 | ((n >> 8_u) as u8), n as u8]/&); + } 3u { - [0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8, - n as u8] + w.write([0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8, + n as u8]/&); } 4u { - [0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8, - (n >> 8_u) as u8, n as u8] + w.write([0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8, + (n >> 8_u) as u8, n as u8]/&); } _ { fail #fmt("vint to write too big: %?", n); } }; - w.write(buf); } fn write_vuint(w: io::writer, n: uint) { @@ -191,7 +194,7 @@ impl writer for writer { // Write a placeholder four-byte size. self.size_positions += [self.writer.tell()]; - let zeroes: [u8] = [0u8, 0u8, 0u8, 0u8]; + let zeroes: [u8]/& = [0u8, 0u8, 0u8, 0u8]/&; self.writer.write(zeroes); } @@ -212,42 +215,54 @@ impl writer for writer { self.end_tag(); } - fn wr_tagged_bytes(tag_id: uint, b: [u8]) { + fn wr_tagged_bytes(tag_id: uint, b: [u8]/&) { write_vuint(self.writer, tag_id); write_vuint(self.writer, vec::len(b)); self.writer.write(b); } fn wr_tagged_u64(tag_id: uint, v: u64) { - self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v, 8u)); + io::u64_to_be_bytes(v, 8u) {|v| + self.wr_tagged_bytes(tag_id, v); + } } fn wr_tagged_u32(tag_id: uint, v: u32) { - self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 4u)); + io::u64_to_be_bytes(v as u64, 4u) {|v| + self.wr_tagged_bytes(tag_id, v); + } } fn wr_tagged_u16(tag_id: uint, v: u16) { - self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 2u)); + io::u64_to_be_bytes(v as u64, 2u) {|v| + self.wr_tagged_bytes(tag_id, v); + } } fn wr_tagged_u8(tag_id: uint, v: u8) { - self.wr_tagged_bytes(tag_id, [v]); + self.wr_tagged_bytes(tag_id, [v]/&); } fn wr_tagged_i64(tag_id: uint, v: i64) { - self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 8u)); + io::u64_to_be_bytes(v as u64, 8u) {|v| + self.wr_tagged_bytes(tag_id, v); + } } fn wr_tagged_i32(tag_id: uint, v: i32) { - self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 4u)); + io::u64_to_be_bytes(v as u64, 4u) {|v| + self.wr_tagged_bytes(tag_id, v); + } } fn wr_tagged_i16(tag_id: uint, v: i16) { - self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 2u)); + io::u64_to_be_bytes(v as u64, 2u) {|v| + self.wr_tagged_bytes(tag_id, v); + } } fn wr_tagged_i8(tag_id: uint, v: i8) { - self.wr_tagged_bytes(tag_id, [v as u8]); + self.wr_tagged_bytes(tag_id, [v as u8]/&); } fn wr_tagged_str(tag_id: uint, v: str) { @@ -260,7 +275,7 @@ impl writer for writer { self.wr_tagged_bytes(tag_id, str::bytes(v)); } - fn wr_bytes(b: [u8]) { + fn wr_bytes(b: [u8]/&) { #debug["Write %u bytes", vec::len(b)]; self.writer.write(b); } diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index 8968be31ce7d..ae3bc4e0a2ce 100644 --- a/src/rustc/metadata/encoder.rs +++ b/src/rustc/metadata/encoder.rs @@ -62,7 +62,7 @@ fn encode_named_def_id(ebml_w: ebml::writer, name: str, id: def_id) { fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) { ebml_w.wr_tag(tag_class_mut) {|| ebml_w.writer.write([alt mt { class_immutable { 'i' } - class_mutable { 'm' } } as u8]); + class_mutable { 'm' } } as u8]/&); } } @@ -230,7 +230,7 @@ fn encode_reexport_paths(ebml_w: ebml::writer, // Item info table encoding fn encode_family(ebml_w: ebml::writer, c: char) { ebml_w.start_tag(tag_items_data_item_family); - ebml_w.writer.write([c as u8]); + ebml_w.writer.write([c as u8]/&); ebml_w.end_tag(); } @@ -1016,7 +1016,7 @@ fn encode_metadata(cx: @crate_ctxt, crate: @crate) -> [u8] { // Pad this, since something (LLVM, presumably) is cutting off the // remaining % 4 bytes. - buf_w.write([0u8, 0u8, 0u8, 0u8]); + buf_w.write([0u8, 0u8, 0u8, 0u8]/&); io::mem_buffer_buf(buf) } diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs index ae7f47e2f319..763e710b07af 100644 --- a/src/rustc/metadata/tyencode.rs +++ b/src/rustc/metadata/tyencode.rs @@ -190,45 +190,45 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { alt t { ty_i { w.write_char('i'); } ty_char { w.write_char('c'); } - ty_i8 { w.write_str("MB"); } - ty_i16 { w.write_str("MW"); } - ty_i32 { w.write_str("ML"); } - ty_i64 { w.write_str("MD"); } + ty_i8 { w.write_str("MB"/&); } + ty_i16 { w.write_str("MW"/&); } + ty_i32 { w.write_str("ML"/&); } + ty_i64 { w.write_str("MD"/&); } } } ty::ty_uint(t) { alt t { ty_u { w.write_char('u'); } - ty_u8 { w.write_str("Mb"); } - ty_u16 { w.write_str("Mw"); } - ty_u32 { w.write_str("Ml"); } - ty_u64 { w.write_str("Md"); } + ty_u8 { w.write_str("Mb"/&); } + ty_u16 { w.write_str("Mw"/&); } + ty_u32 { w.write_str("Ml"/&); } + ty_u64 { w.write_str("Md"/&); } } } ty::ty_float(t) { alt t { ty_f { w.write_char('l'); } - ty_f32 { w.write_str("Mf"); } - ty_f64 { w.write_str("MF"); } + ty_f32 { w.write_str("Mf"/&); } + ty_f64 { w.write_str("MF"/&); } } } ty::ty_str { w.write_char('S'); } ty::ty_enum(def, substs) { - w.write_str("t["); + w.write_str("t["/&); w.write_str(cx.ds(def)); w.write_char('|'); enc_substs(w, cx, substs); w.write_char(']'); } ty::ty_iface(def, tys) { - w.write_str("x["); + w.write_str("x["/&); w.write_str(cx.ds(def)); w.write_char('|'); for tys.each {|t| enc_ty(w, cx, t); } w.write_char(']'); } ty::ty_tup(ts) { - w.write_str("T["); + w.write_str("T["/&); for ts.each {|t| enc_ty(w, cx, t); } w.write_char(']'); } @@ -251,7 +251,7 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { } ty::ty_vec(mt) { w.write_char('I'); enc_mt(w, cx, mt); } ty::ty_rec(fields) { - w.write_str("R["); + w.write_str("R["/&); for fields.each {|field| w.write_str(field.ident); w.write_char('='); @@ -264,7 +264,7 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { enc_ty_fn(w, cx, f); } ty::ty_res(def, ty, substs) { - w.write_str("r["); + w.write_str("r["/&); w.write_str(cx.ds(def)); w.write_char('|'); enc_ty(w, cx, ty); @@ -282,16 +282,16 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { w.write_str(uint::str(id)); } ty::ty_self(tps) { - w.write_str("s["); + w.write_str("s["/&); for tps.each {|t| enc_ty(w, cx, t); } w.write_char(']'); } ty::ty_type { w.write_char('Y'); } - ty::ty_opaque_closure_ptr(ty::ck_block) { w.write_str("C&"); } - ty::ty_opaque_closure_ptr(ty::ck_box) { w.write_str("C@"); } - ty::ty_opaque_closure_ptr(ty::ck_uniq) { w.write_str("C~"); } + ty::ty_opaque_closure_ptr(ty::ck_block) { w.write_str("C&"/&); } + ty::ty_opaque_closure_ptr(ty::ck_box) { w.write_str("C@"/&); } + ty::ty_opaque_closure_ptr(ty::ck_uniq) { w.write_str("C~"/&); } ty::ty_constr(ty, cs) { - w.write_str("A["); + w.write_str("A["/&); enc_ty(w, cx, ty); for cs.each {|tc| enc_ty_constr(w, cx, tc); } w.write_char(']'); @@ -299,12 +299,12 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { ty::ty_opaque_box { w.write_char('B'); } ty::ty_class(def, substs) { #debug("~~~~ %s", "a["); - w.write_str("a["); + w.write_str("a["/&); let s = cx.ds(def); #debug("~~~~ %s", s); w.write_str(s); #debug("~~~~ %s", "|"); - w.write_str("|"); + w.write_char('|'); enc_substs(w, cx, substs); #debug("~~~~ %s", "]"); w.write_char(']'); @@ -313,11 +313,11 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) { } fn enc_proto(w: io::writer, proto: proto) { alt proto { - proto_uniq { w.write_str("f~"); } - proto_box { w.write_str("f@"); } + proto_uniq { w.write_str("f~"/&); } + proto_box { w.write_str("f@"/&); } proto_block { w.write_str("f&"); } - proto_any { w.write_str("f*"); } - proto_bare { w.write_str("fn"); } + proto_any { w.write_str("f*"/&); } + proto_bare { w.write_str("fn"/&); } } } diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index 4e69bba7eccd..12067f83cc66 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -80,7 +80,7 @@ fn chanmb(i: uint, size: uint, ch: comm::chan) -> () type devnull = {dn: int}; impl of io::writer for devnull { - fn write(_b: [const u8]) {} + fn write(_b: [const u8]/&) {} fn seek(_i: int, _s: io::seek_style) {} fn tell() -> uint {0_u} fn flush() -> int {0}