Encode/decode AST into metadata, re-instantiate inlined items

4 files changed, 310 insertions, 118 deletions

diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 45faf62cf7d..9e39042ded1 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -6,11 +6,31 @@
 import core::option;
 import option::{some, none};
 
+export doc;
+
+export new_doc;
+export doc_at;
+export maybe_get_doc;
+export get_doc;
+export docs;
+export tagged_docs;
+export doc_data;
+export doc_as_str;
+export doc_as_u8;
+export doc_as_u16;
+export doc_as_u32;
+export doc_as_u64;
+export doc_as_i8;
+export doc_as_i16;
+export doc_as_i32;
+export doc_as_i64;
+export writer;
+export mk_writer;
+
 type ebml_tag = {id: uint, size: uint};
 
 type ebml_state = {ebml_tag: ebml_tag, tag_pos: uint, data_pos: uint};
 
-
 // TODO: When we have module renaming, make "reader" and "writer" separate
 // modules within this file.
 
@@ -19,35 +39,29 @@ type doc = {data: @[u8], start: uint, end: uint};
 
 type tagged_doc = {tag: uint, doc: doc};
 
-fn vu64_at(data: [u8], start: uint) -> {val: u64, 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 u64, next: start + 1u};
+        ret {val: (a & 0x7fu8) as uint, next: start + 1u};
     }
     if a & 0x40u8 != 0u8 {
-        ret {val: ((a & 0x3fu8) as u64) << 8u64 |
-                 (data[start + 1u] as u64),
+        ret {val: ((a & 0x3fu8) as uint) << 8u |
+                 (data[start + 1u] as uint),
              next: start + 2u};
     } else if a & 0x20u8 != 0u8 {
-        ret {val: ((a & 0x1fu8) as u64) << 16u64 |
-                 (data[start + 1u] as u64) << 8u64 |
-                 (data[start + 2u] as u64),
+        ret {val: ((a & 0x1fu8) as uint) << 16u |
+                 (data[start + 1u] as uint) << 8u |
+                 (data[start + 2u] as uint),
              next: start + 3u};
     } else if a & 0x10u8 != 0u8 {
-        ret {val: ((a & 0x0fu8) as u64) << 24u64 |
-                 (data[start + 1u] as u64) << 16u64 |
-                 (data[start + 2u] as u64) << 8u64 |
-                 (data[start + 3u] as u64),
+        ret {val: ((a & 0x0fu8) as uint) << 24u |
+                 (data[start + 1u] as uint) << 16u |
+                 (data[start + 2u] as uint) << 8u |
+                 (data[start + 3u] as uint),
              next: start + 4u};
     } else { #error("vint too big"); fail; }
 }
 
-fn vuint_at(data: [u8], start: uint) -> {val: uint, next: uint} {
-    let {val, next} = vu64_at(data, start);
-    ret {val: val as uint, next: next};
-}
-
-
 fn new_doc(data: @[u8]) -> doc {
     ret {data: data, start: 0u, end: vec::len::<u8>(*data)};
 }
@@ -77,7 +91,7 @@ fn get_doc(d: doc, tg: uint) -> doc {
     alt maybe_get_doc(d, tg) {
       some(d) { ret d; }
       none {
-        #error("failed to find block with enum %u", tg);
+        #error("failed to find block with tag %u", tg);
         fail;
       }
     }
@@ -107,111 +121,144 @@ fn tagged_docs(d: doc, tg: uint, it: fn(doc)) {
 
 fn doc_data(d: doc) -> [u8] { ret vec::slice::<u8>(*d.data, d.start, d.end); }
 
-fn doc_str(d: doc) -> str { ret str::from_bytes(doc_data(d)); }
-
-fn be_u64_from_bytes(data: @[u8], start: uint, size: uint) -> u64 {
-    let sz = size;
-    assert (sz <= 4u);
-    let val = 0_u64;
-    let pos = start;
-    while sz > 0u {
-        sz -= 1u;
-        val += (data[pos] as u64) << ((sz * 8u) as u64);
-        pos += 1u;
-    }
-    ret val;
-}
+fn doc_as_str(d: doc) -> str { ret str::from_bytes(doc_data(d)); }
 
 fn doc_as_u8(d: doc) -> u8 {
     assert d.end == d.start + 1u;
     ret (*d.data)[d.start];
 }
 
-fn doc_as_vu64(d: doc) -> u64 {
-    ret vu64_at(*d.data, d.start).val;
+fn doc_as_u16(d: doc) -> u16 {
+    assert d.end == d.start + 2u;
+    ret io::u64_from_be_bytes(*d.data, d.start, 2u) as u16;
+}
+
+fn doc_as_u32(d: doc) -> u32 {
+    assert d.end == d.start + 4u;
+    ret io::u64_from_be_bytes(*d.data, d.start, 4u) as u32;
 }
 
-fn doc_as_vuint(d: doc) -> uint {
-    ret vuint_at(*d.data, d.start).val;
+fn doc_as_u64(d: doc) -> u64 {
+    assert d.end == d.start + 8u;
+    ret io::u64_from_be_bytes(*d.data, d.start, 8u);
 }
 
+fn doc_as_i8(d: doc) -> i8 { doc_as_u8(d) as i8 }
+fn doc_as_i16(d: doc) -> i16 { doc_as_u16(d) as i16 }
+fn doc_as_i32(d: doc) -> i32 { doc_as_u32(d) as i32 }
+fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 }
+
 // ebml writing
 type writer = {writer: io::writer, mutable size_positions: [uint]};
 
-fn write_sized_vu64(w: io::writer, n: u64, size: uint) {
+fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
     let buf: [u8];
     alt size {
       1u { buf = [0x80u8 | (n as u8)]; }
-      2u { buf = [0x40u8 | ((n >> 8_u64) as u8), n as u8]; }
+      2u { buf = [0x40u8 | ((n >> 8_u) as u8), n as u8]; }
       3u {
-        buf = [0x20u8 | ((n >> 16_u64) as u8), (n >> 8_u64) as u8,
+        buf = [0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
                n as u8];
       }
       4u {
-        buf = [0x10u8 | ((n >> 24_u64) as u8), (n >> 16_u64) as u8,
-               (n >> 8_u64) as u8, n as u8];
+        buf = [0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
+               (n >> 8_u) as u8, n as u8];
       }
-      _ { #error("vint to write too big"); fail; }
+      _ { fail #fmt("vint to write too big: %?", n); }
     }
     w.write(buf);
 }
 
-fn write_vu64(w: io::writer, n: u64) {
-    if n < 0x7f_u64 { write_sized_vu64(w, n, 1u); ret; }
-    if n < 0x4000_u64 { write_sized_vu64(w, n, 2u); ret; }
-    if n < 0x200000_u64 { write_sized_vu64(w, n, 3u); ret; }
-    if n < 0x10000000_u64 { write_sized_vu64(w, n, 4u); ret; }
-    #error("vint to write too big");
-    fail;
+fn write_vuint(w: io::writer, n: uint) {
+    if n < 0x7f_u { write_sized_vuint(w, n, 1u); ret; }
+    if n < 0x4000_u { write_sized_vuint(w, n, 2u); ret; }
+    if n < 0x200000_u { write_sized_vuint(w, n, 3u); ret; }
+    if n < 0x10000000_u { write_sized_vuint(w, n, 4u); ret; }
+    fail #fmt("vint to write too big: %?", n);
 }
 
-fn create_writer(w: io::writer) -> writer {
+fn mk_writer(w: io::writer) -> writer {
     let size_positions: [uint] = [];
     ret {writer: w, mutable size_positions: size_positions};
 }
 
-
 // TODO: Provide a function to write the standard ebml header.
-fn start_tag(w: writer, tag_id: uint) {
-    #debug["Start tag %u", tag_id];
+impl writer for writer {
+    fn start_tag(tag_id: uint) {
+        #debug["Start tag %u", tag_id];
 
-    // Write the enum ID:
-    write_vu64(w.writer, tag_id as u64);
+        // Write the enum ID:
+        write_vuint(self.writer, tag_id);
 
-    // Write a placeholder four-byte size.
-    w.size_positions += [w.writer.tell()];
-    let zeroes: [u8] = [0u8, 0u8, 0u8, 0u8];
-    w.writer.write(zeroes);
-}
+        // Write a placeholder four-byte size.
+        self.size_positions += [self.writer.tell()];
+        let zeroes: [u8] = [0u8, 0u8, 0u8, 0u8];
+        self.writer.write(zeroes);
+    }
 
-fn end_tag(w: writer) {
-    let last_size_pos = vec::pop::<uint>(w.size_positions);
-    let cur_pos = w.writer.tell();
-    w.writer.seek(last_size_pos as int, io::seek_set);
-    let size = (cur_pos - last_size_pos - 4u);
-    write_sized_vu64(w.writer, size as u64, 4u);
-    w.writer.seek(cur_pos as int, io::seek_set);
+    fn end_tag() {
+        let last_size_pos = vec::pop::<uint>(self.size_positions);
+        let cur_pos = self.writer.tell();
+        self.writer.seek(last_size_pos as int, io::seek_set);
+        let size = (cur_pos - last_size_pos - 4u);
+        write_sized_vuint(self.writer, size, 4u);
+        self.writer.seek(cur_pos as int, io::seek_set);
 
-    #debug["End tag (size = %u)", size];
-}
+        #debug["End tag (size = %u)", size];
+    }
 
-impl writer_util for writer {
     fn wr_tag(tag_id: uint, blk: fn()) {
-        start_tag(self, tag_id);
+        self.start_tag(tag_id);
         blk();
-        end_tag(self);
+        self.end_tag();
     }
 
-    fn wr_vu64(id: u64) {
-        #debug["Write u64 0x%02x%02x",
-               (id >> 32u64) as uint,
-               (id & 0xFFFFFFFFu64) as uint];
-        write_vu64(self.writer, id);
+    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));
+    }
+
+    fn wr_tagged_u32(tag_id: uint, v: u32) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 4u));
+    }
+
+    fn wr_tagged_u16(tag_id: uint, v: u16) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 2u));
+    }
+
+    fn wr_tagged_u8(tag_id: uint, v: u8) {
+        self.wr_tagged_bytes(tag_id, [v]);
     }
 
-    fn wr_vuint(id: uint) {
-        #debug["Write uint: %u", id];
-        write_vu64(self.writer, id as u64);
+    fn wr_tagged_i64(tag_id: uint, v: i64) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 8u));
+    }
+
+    fn wr_tagged_i32(tag_id: uint, v: i32) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 4u));
+    }
+
+    fn wr_tagged_i16(tag_id: uint, v: i16) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 2u));
+    }
+
+    fn wr_tagged_i8(tag_id: uint, v: i8) {
+        self.wr_tagged_bytes(tag_id, [v as u8]);
+    }
+
+    fn wr_tagged_str(tag_id: uint, v: str) {
+        // Lame: can't use str::as_bytes() here because the resulting
+        // vector is NULL-terminated.  Annoyingly, the underlying
+        // writer interface doesn't permit us to write a slice of a
+        // vector.  We need first-class slices, I think.
+
+        // str::as_bytes(v) {|b| self.wr_tagged_bytes(tag_id, b); }
+        self.wr_tagged_bytes(tag_id, str::bytes(v));
     }
 
     fn wr_bytes(b: [u8]) {
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 0fb000c8315..1efd91d54db 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -366,19 +366,41 @@ fn mk_file_writer(path: str, flags: [fileflag])
     }
 }
 
-fn uint_to_le_bytes(n: uint, size: uint) -> [u8] {
+fn u64_to_le_bytes(n: u64, size: uint) -> [u8] {
     let bytes: [u8] = [], i = size, n = n;
-    while i > 0u { bytes += [(n & 255u) as u8]; n >>= 8u; i -= 1u; }
+    while i > 0u {
+        bytes += [(n & 255_u64) as u8];
+        n >>= 8_u64;
+        i -= 1u;
+    }
     ret bytes;
 }
 
-fn uint_to_be_bytes(n: uint, size: uint) -> [u8] {
+fn u64_to_be_bytes(n: u64, size: uint) -> [u8] {
+    assert size <= 8u;
     let bytes: [u8] = [];
-    let i = (size - 1u) as int;
-    while i >= 0 { bytes += [(n >> ((i * 8) as uint) & 255u) as u8]; i -= 1; }
+    let i = size;
+    while i > 0u {
+        let shift = ((i - 1u) * 8u) as u64;
+        bytes += [(n >> shift) as u8];
+        i -= 1u;
+    }
     ret bytes;
 }
 
+fn u64_from_be_bytes(data: [u8], start: uint, size: uint) -> u64 {
+    let sz = size;
+    assert (sz <= 8u);
+    let val = 0_u64;
+    let pos = start;
+    while sz > 0u {
+        sz -= 1u;
+        val += (data[pos] as u64) << ((sz * 8u) as u64);
+        pos += 1u;
+    }
+    ret val;
+}
+
 impl writer_util for writer {
     fn write_char(ch: char) {
         if ch as uint < 128u {
@@ -393,14 +415,36 @@ impl writer_util for writer {
     fn write_uint(n: uint) { self.write(str::bytes(uint::to_str(n, 10u))); }
 
     fn write_le_uint(n: uint, size: uint) {
-        self.write(uint_to_le_bytes(n, size));
+        self.write(u64_to_le_bytes(n as u64, size));
     }
     fn write_le_int(n: int, size: uint) {
-        self.write(uint_to_le_bytes(n as uint, size));
+        self.write(u64_to_le_bytes(n as u64, size));
     }
+
     fn write_be_uint(n: uint, size: uint) {
-        self.write(uint_to_be_bytes(n, size));
+        self.write(u64_to_be_bytes(n as u64, size));
+    }
+    fn write_be_int(n: int, size: uint) {
+        self.write(u64_to_be_bytes(n as u64, size));
     }
+
+    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 file_writer(path: str, flags: [fileflag]) -> result::t<writer, str> {
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index 1cc8cb529d8..c1c862cd386 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -5,15 +5,25 @@ Support code for serialization.
 */
 
 import list::list;
-import ebml::writer_util;
+import ebml::writer;
 
 iface serializer {
     // Primitive types:
     fn emit_nil();
+    fn emit_uint(v: uint);
     fn emit_u64(v: u64);
+    fn emit_u32(v: u32);
+    fn emit_u16(v: u16);
+    fn emit_u8(v: u8);
+    fn emit_int(v: int);
     fn emit_i64(v: i64);
+    fn emit_i32(v: i32);
+    fn emit_i16(v: i16);
+    fn emit_i8(v: i8);
     fn emit_bool(v: bool);
+    fn emit_float(v: float);
     fn emit_f64(v: f64);
+    fn emit_f32(v: f32);
     fn emit_str(v: str);
 
     // Compound types:
@@ -33,12 +43,28 @@ iface serializer {
 iface deserializer {
     // Primitive types:
     fn read_nil() -> ();
+
+    fn read_uint() -> uint;
     fn read_u64() -> u64;
+    fn read_u32() -> u32;
+    fn read_u16() -> u16;
+    fn read_u8() -> u8;
+
+    fn read_int() -> int;
     fn read_i64() -> i64;
+    fn read_i32() -> i32;
+    fn read_i16() -> i16;
+    fn read_i8() -> i8;
+
+
     fn read_bool() -> bool;
-    fn read_f64() -> f64;
+
     fn read_str() -> str;
 
+    fn read_f64() -> f64;
+    fn read_f32() -> f32;
+    fn read_float() -> float;
+
     // Compound types:
     fn read_enum<T:copy>(name: str, f: fn() -> T) -> T;
     fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T;
@@ -54,8 +80,11 @@ iface deserializer {
 }
 
 enum ebml_serializer_tag {
-    es_u64, es_i64, es_bool,
+    es_uint, es_u64, es_u32, es_u16, es_u8,
+    es_int, es_i64, es_i32, es_i16, es_i8,
+    es_bool,
     es_str,
+    es_f64, es_f32, es_float,
     es_enum, es_enum_vid, es_enum_body,
     es_vec, es_vec_len, es_vec_elt
 }
@@ -63,38 +92,54 @@ enum ebml_serializer_tag {
 impl of serializer for ebml::writer {
     fn emit_nil() {}
 
-    fn emit_num(tag: ebml_serializer_tag, v: u64) {
-        self.wr_tag(tag as uint) {|| self.wr_vu64(v) }
+    // used internally to emit things like the vector length and so on
+    fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint) {
+        assert v <= 0xFFFF_FFFF_u;
+        self.wr_tagged_u32(t as uint, v as u32);
     }
 
-    fn emit_u64(v: u64) { self.emit_num(es_u64, v) }
-    fn emit_i64(v: i64) { self.emit_num(es_i64, v as u64) }
-    fn emit_bool(v: bool) { self.emit_num(es_bool, v as u64) }
+    fn emit_uint(v: uint) { self.wr_tagged_u64(es_uint as uint, v as u64); }
+    fn emit_u64(v: u64) { self.wr_tagged_u64(es_u64 as uint, v); }
+    fn emit_u32(v: u32) { self.wr_tagged_u32(es_u32 as uint, v); }
+    fn emit_u16(v: u16) { self.wr_tagged_u16(es_u16 as uint, v); }
+    fn emit_u8(v: u8)   { self.wr_tagged_u8 (es_u8  as uint, v); }
+
+    fn emit_int(v: int) { self.wr_tagged_i64(es_int as uint, v as i64); }
+    fn emit_i64(v: i64) { self.wr_tagged_i64(es_i64 as uint, v); }
+    fn emit_i32(v: i32) { self.wr_tagged_i32(es_i32 as uint, v); }
+    fn emit_i16(v: i16) { self.wr_tagged_i16(es_i16 as uint, v); }
+    fn emit_i8(v: i8)   { self.wr_tagged_i8 (es_i8  as uint, v); }
+
+    fn emit_bool(v: bool) { self.wr_tagged_u8(es_bool as uint, v as u8) }
+
     fn emit_f64(_v: f64) { fail "TODO"; }
-    fn emit_str(v: str) { self.wr_tag(es_str as uint) {|| self.wr_str(v) } }
+    fn emit_f32(_v: f32) { fail "TODO"; }
+    fn emit_float(_v: float) { fail "TODO"; }
+
+    fn emit_str(v: str) { self.wr_tagged_str(es_str as uint, v) }
 
     fn emit_enum(_name: str, f: fn()) {
-        self.wr_tag(es_enum as uint) {|| f() }
+        self.wr_tag(es_enum as uint, f)
     }
     fn emit_enum_variant(_v_name: str, v_id: uint, _cnt: uint, f: fn()) {
-        self.emit_num(es_enum_vid, v_id as u64);
-        self.wr_tag(es_enum_body as uint) {|| f() }
+        self._emit_tagged_uint(es_enum_vid, v_id);
+        self.wr_tag(es_enum_body as uint, f)
     }
     fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() }
 
     fn emit_vec(len: uint, f: fn()) {
         self.wr_tag(es_vec as uint) {||
-            self.emit_num(es_vec_len, len as u64);
+            self._emit_tagged_uint(es_vec_len, len);
             f()
         }
     }
 
     fn emit_vec_elt(_idx: uint, f: fn()) {
-        self.wr_tag(es_vec_elt as uint) {|| f() }
+        self.wr_tag(es_vec_elt as uint, f)
     }
 
     fn emit_vec_elt(_idx: uint, f: fn()) {
-        self.wr_tag(es_vec_elt as uint) {|| f() }
+        self.wr_tag(es_vec_elt as uint, f)
     }
 
     fn emit_box(f: fn()) { f() }
@@ -145,18 +190,45 @@ impl of deserializer for ebml_deserializer {
         ret r;
     }
 
-    fn next_u64(exp_tag: ebml_serializer_tag) -> u64 {
-        let r = ebml::doc_as_vu64(self.next_doc(exp_tag));
-        #debug["next_u64 exp_tag=%? result=%?", exp_tag, r];
-        ret r;
+    fn _next_uint(exp_tag: ebml_serializer_tag) -> uint {
+        let r = ebml::doc_as_u32(self.next_doc(exp_tag));
+        #debug["_next_uint exp_tag=%? result=%?", exp_tag, r];
+        ret r as uint;
     }
 
     fn read_nil() -> () { () }
-    fn read_u64() -> u64 { self.next_u64(es_u64) }
-    fn read_i64() -> i64 { self.next_u64(es_i64) as i64 }
-    fn read_bool() -> bool { self.next_u64(es_bool) as bool }
-    fn read_f64() -> f64 { fail "Float"; }
-    fn read_str() -> str { ebml::doc_str(self.next_doc(es_str)) }
+
+    fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(es_u64)) }
+    fn read_u32() -> u32 { ebml::doc_as_u32(self.next_doc(es_u32)) }
+    fn read_u16() -> u16 { ebml::doc_as_u16(self.next_doc(es_u16)) }
+    fn read_u8 () -> u8  { ebml::doc_as_u8 (self.next_doc(es_u8 )) }
+    fn read_uint() -> uint {
+        let v = ebml::doc_as_u64(self.next_doc(es_uint));
+        if v > (uint::max_value as u64) {
+            fail #fmt["uint %? too large for this architecture", v];
+        }
+        ret v as uint;
+    }
+
+    fn read_i64() -> i64 { ebml::doc_as_u64(self.next_doc(es_i64)) as i64 }
+    fn read_i32() -> i32 { ebml::doc_as_u32(self.next_doc(es_i32)) as i32 }
+    fn read_i16() -> i16 { ebml::doc_as_u16(self.next_doc(es_i16)) as i16 }
+    fn read_i8 () -> i8  { ebml::doc_as_u8 (self.next_doc(es_i8 )) as i8  }
+    fn read_int() -> int {
+        let v = ebml::doc_as_u64(self.next_doc(es_int)) as i64;
+        if v > (int::max_value as i64) || v < (int::min_value as i64) {
+            fail #fmt["int %? out of range for this architecture", v];
+        }
+        ret v as int;
+    }
+
+    fn read_bool() -> bool { ebml::doc_as_u8(self.next_doc(es_bool)) as bool }
+
+    fn read_f64() -> f64 { fail "read_f64()"; }
+    fn read_f32() -> f32 { fail "read_f32()"; }
+    fn read_float() -> float { fail "read_float()"; }
+
+    fn read_str() -> str { ebml::doc_as_str(self.next_doc(es_str)) }
 
     // Compound types:
     fn read_enum<T:copy>(_name: str, f: fn() -> T) -> T {
@@ -164,7 +236,7 @@ impl of deserializer for ebml_deserializer {
     }
 
     fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T {
-        let idx = self.next_u64(es_enum_vid) as uint;
+        let idx = self._next_uint(es_enum_vid);
         self.push_doc(self.next_doc(es_enum_body)) {||
             f(idx)
         }
@@ -176,7 +248,7 @@ impl of deserializer for ebml_deserializer {
 
     fn read_vec<T:copy>(f: fn(uint) -> T) -> T {
         self.push_doc(self.next_doc(es_vec)) {||
-            let len = self.next_u64(es_vec_len) as uint;
+            let len = self._next_uint(es_vec_len);
             f(len)
         }
     }
@@ -211,6 +283,36 @@ impl of deserializer for ebml_deserializer {
 }
 
 // ___________________________________________________________________________
+// Helper routines
+//
+// These should eventually be coded as traits.
+
+impl serializer_helpers<S: serializer> for S {
+    fn emit_from_vec<T>(v: [T], f: fn(T)) {
+        self.emit_vec(vec::len(v)) {||
+            vec::iteri(v) {|i,e|
+                self.emit_vec_elt(i) {||
+                    f(e)
+                }
+            }
+        }
+    }
+}
+
+impl deserializer_helpers<D: deserializer> for D {
+    fn read_to_vec<T>(f: fn() -> T) -> [T] {
+        self.read_vec {|len|
+            let v = [];
+            vec::reserve(v, len);
+            uint::range(0u, len) {|i|
+                self.read_vec_elt(i) {|| v += [f()] }
+            }
+            v
+        }
+    }
+}
+
+// ___________________________________________________________________________
 // Testing
 
 #[test]
@@ -257,7 +359,7 @@ fn test_option_int() {
     fn test_v(v: option<int>) {
         #debug["v == %?", v];
         let mbuf = io::mk_mem_buffer();
-        let ebml_w = ebml::create_writer(io::mem_buffer_writer(mbuf));
+        let ebml_w = ebml::mk_writer(io::mem_buffer_writer(mbuf));
         serialize_0(ebml_w, v);
         let ebml_doc = ebml::new_doc(@io::mem_buffer_buf(mbuf));
         let deser = mk_ebml_deserializer(ebml_doc);
diff --git a/src/libstd/std.rc b/src/libstd/std.rc
index 695a45f9be7..478dbb69513 100644
--- a/src/libstd/std.rc
+++ b/src/libstd/std.rc
@@ -12,7 +12,7 @@ export c_vec, four, tri, util;
 export bitv, deque, fun_treemap, list, map, smallintmap, sort, treemap, ufind;
 export rope;
 export ebml, dbg, getopts, json, rand, sha1, term, time;
-export test, tempfile;
+export test, tempfile, serialization;
 // FIXME: generic_os and os_fs shouldn't be exported
 export generic_os, os, os_fs;
 
@@ -111,5 +111,4 @@ mod os_fs;
 // indent-tabs-mode: nil
 // c-basic-offset: 4
 // buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
 // End: