create serialization lib and update serializer to use it

Author: nikomatsakis

src/comp/metadata/decoder.rs

@@ -43,15 +43,15 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
     let table = ebml::get_doc(index, tag_index_table);
     let hash_pos = table.start + hash % 256u * 4u;
     let pos = ebml::be_uint_from_bytes(d.data, hash_pos, 4u);
-    let bucket = ebml::doc_at(d.data, pos);
+    let {tag:_, doc:bucket} = ebml::doc_at(d.data, pos);
     // Awkward logic because we can't ret from foreach yet
 
     let result: [ebml::doc] = [];
     let belt = tag_index_buckets_bucket_elt;
     ebml::tagged_docs(bucket, belt) {|elt|
         let pos = ebml::be_uint_from_bytes(elt.data, elt.start, 4u);
         if eq_fn(vec::slice::<u8>(*elt.data, elt.start + 4u, elt.end)) {
-            result += [ebml::doc_at(d.data, pos)];
+            result += [ebml::doc_at(d.data, pos).doc];
         }
     };
     ret result;
@@ -500,7 +500,7 @@ fn iter_crate_items(bytes: @[u8], proc: fn(str, ast::def_id)) {
         let et = tag_index_buckets_bucket_elt;
         ebml::tagged_docs(bucket, et) {|elt|
             let data = read_path(elt);
-            let def = ebml::doc_at(bytes, data.pos);
+            let {tag:_, doc:def} = ebml::doc_at(bytes, data.pos);
             let did_doc = ebml::get_doc(def, tag_def_id);
             let did = parse_def_id(ebml::doc_data(did_doc));
             proc(data.path, did);

src/comp/middle/ty.rs

@@ -2395,7 +2395,7 @@ fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
             *path + [ast_map::path_name(nitem.ident)]
           }
 
-          ast_map::node_method(method, path) {
+          ast_map::node_method(method, _, path) {
             *path + [ast_map::path_name(method.ident)]
           }
 

src/libstd/ebml.rs

@@ -17,6 +17,8 @@ type ebml_state = {ebml_tag: ebml_tag, tag_pos: uint, data_pos: uint};
 // ebml reading
 type doc = {data: @[u8], start: uint, end: uint};
 
+type tagged_doc = {tag: uint, doc: doc};
+
 fn vint_at(data: [u8], start: uint) -> {val: uint, next: uint} {
     let a = data[start];
     if a & 0x80u8 != 0u8 {
@@ -43,11 +45,12 @@ fn new_doc(data: @[u8]) -> doc {
     ret {data: data, start: 0u, end: vec::len::<u8>(*data)};
 }
 
-fn doc_at(data: @[u8], start: uint) -> doc {
+fn doc_at(data: @[u8], start: uint) -> tagged_doc {
     let elt_tag = vint_at(*data, start);
     let elt_size = vint_at(*data, elt_tag.next);
     let end = elt_size.next + elt_size.val;
-    ret {data: data, start: elt_size.next, end: end};
+    ret {tag: elt_tag.val,
+         doc: {data: data, start: elt_size.next, end: end}};
 }
 
 fn maybe_get_doc(d: doc, tg: uint) -> option<doc> {
@@ -120,18 +123,18 @@ fn doc_as_uint(d: doc) -> uint {
 // ebml writing
 type writer = {writer: io::writer, mutable size_positions: [uint]};
 
-fn write_sized_vint(w: io::writer, n: uint, size: uint) {
+fn write_sized_vint(w: io::writer, n: u64, size: uint) {
     let buf: [u8];
     alt size {
       1u { buf = [0x80u8 | (n as u8)]; }
-      2u { buf = [0x40u8 | ((n >> 8u) as u8), (n & 0xffu) as u8]; }
+      2u { buf = [0x40u8 | ((n >> 8_u64) as u8), n as u8]; }
       3u {
-        buf = [0x20u8 | ((n >> 16u) as u8), (n >> 8u & 0xffu) as u8,
-               (n & 0xffu) as u8];
+        buf = [0x20u8 | ((n >> 16_u64) as u8), (n >> 8_u64) as u8,
+               n as u8];
       }
       4u {
-        buf = [0x10u8 | ((n >> 24u) as u8), (n >> 16u & 0xffu) as u8,
-               (n >> 8u & 0xffu) as u8, (n & 0xffu) as u8];
+        buf = [0x10u8 | ((n >> 24_u64) as u8), (n >> 16_u64) as u8,
+               (n >> 8_u64) as u8, n as u8];
       }
       _ { #error("vint to write too big"); fail; }
     }
@@ -156,7 +159,7 @@ fn create_writer(w: io::writer) -> writer {
 // TODO: Provide a function to write the standard ebml header.
 fn start_tag(w: writer, tag_id: uint) {
     // Write the enum ID:
-    write_vint(w.writer, tag_id);
+    write_vint(w.writer, tag_id as u64);
 
     // Write a placeholder four-byte size.
     w.size_positions += [w.writer.tell()];
@@ -168,7 +171,7 @@ 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);
-    write_sized_vint(w.writer, cur_pos - last_size_pos - 4u, 4u);
+    write_sized_vint(w.writer, (cur_pos - last_size_pos - 4u) as u64, 4u);
     w.writer.seek(cur_pos as int, io::seek_set);
 }
 
@@ -179,12 +182,12 @@ impl writer_util for writer {
         end_tag(self);
     }
 
-    fn wr_uint(id: u64) {
+    fn wr_u64(id: u64) {
         write_vint(self.writer, id);
     }
 
-    fn wr_int(id: uint) {
-        write_vint(self.writer, id);
+    fn wr_uint(id: uint) {
+        self.wr_u64(id as u64);
     }
 
     fn wr_bytes(b: [u8]) {

src/libstd/serialization.rs

@@ -0,0 +1,252 @@
+/*
+Module: serialization
+
+Support code for serialization.
+*/
+
+import list::list;
+
+iface serializer {
+    // Primitive types:
+    fn emit_nil();
+    fn emit_u64(v: u64);
+    fn emit_i64(v: u64);
+    fn emit_bool(v: bool);
+    fn emit_f64(v: f64);
+    fn emit_str(v: str);
+
+    // Compound types:
+    fn emit_enum(name: str, f: fn());
+    fn emit_enum_variant(v_name: str, v_id: uint, sz: uint, f: fn());
+    fn emit_enum_variant_arg(idx: uint, f: fn());
+    fn emit_vec(len: uint, f: fn());
+    fn emit_vec_elt(idx: uint, f: fn());
+    fn emit_box(f: fn());
+    fn emit_uniq(f: fn());
+    fn emit_rec(f: fn());
+    fn emit_rec_field(f_name: str, f_idx: uint, f: fn());
+    fn emit_tup(sz: uint, f: fn());
+    fn emit_tup_elt(idx: uint, f: fn());
+}
+
+iface deserializer {
+    // Primitive types:
+    fn read_nil() -> ();
+    fn read_u64() -> u64;
+    fn read_i64() -> i64;
+    fn read_bool() -> bool;
+    fn read_f64() -> f64;
+    fn read_str() -> str;
+
+    // Compound types:
+    fn read_enum<T:copy>(name: str, f: fn() -> T) -> T;
+    fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T;
+    fn read_enum_variant_arg<T:copy>(idx: uint, f: fn() -> T) -> T;
+    fn read_vec<T:copy>(f: fn(uint) -> T) -> T;
+    fn read_vec_elt<T:copy>(idx: uint, f: fn() -> T) -> T;
+    fn read_box<T:copy>(f: fn() -> T) -> T;
+    fn read_uniq<T:copy>(f: fn() -> T) -> T;
+    fn read_rec<T:copy>(f: fn() -> T) -> T;
+    fn read_rec_field<T:copy>(f_name: str, f_idx: uint, f: fn() -> T) -> T;
+    fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T;
+    fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T;
+}
+
+/*
+type ppserializer = {
+    writer: io::writer
+};
+
+impl serializer for ppserializer {
+    fn emit_nil() { self.writer.write_str("()") }
+
+    fn emit_u64(v: u64) { self.writer.write_str(#fmt["%lu", v]); }
+    fn emit_i64(v: u64) { ebml::write_vint(self, v as uint) }
+    fn emit_bool(v: bool) { ebml::write_vint(self, v as uint) }
+    fn emit_f64(v: f64) { fail "float serialization not impl"; }
+    fn emit_str(v: str) {
+        self.wr_tag(es_str as uint) {|| self.wr_str(v) }
+    }
+
+    fn emit_enum(name: str, f: fn()) {
+        self.wr_tag(es_enum as uint) {|| f() }
+    }
+    fn emit_enum_variant(v_name: str, v_id: uint, f: fn()) {
+        self.wr_tag(es_enum_vid as uint) {|| self.write_vint(v_id) }
+        self.wr_tag(es_enum_body as uint) {|| f() }
+    }
+
+    fn emit_vec(len: uint, f: fn()) {
+        self.wr_tag(es_vec as uint) {||
+            self.wr_tag(es_vec_len as uint) {|| self.write_vint(len) }
+            f()
+        }
+    }
+
+    fn emit_vec_elt(idx: uint, f: fn()) {
+        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() }
+    }
+
+    fn emit_box(f: fn()) { f() }
+    fn emit_uniq(f: fn()) { f() }
+    fn emit_rec_field(f_name: str, f_idx: uint, f: fn()) { f() }
+    fn emit_tup(sz: uint, f: fn()) { f() }
+    fn emit_tup_elt(idx: uint, f: fn()) { f() }
+}
+*/
+
+enum ebml_serializer_tags {
+    es_str,
+    es_enum, es_enum_vid, es_enum_body,
+    es_vec, es_vec_len, es_vec_elt
+}
+
+impl of serializer for ebml::writer {
+    fn emit_nil() {}
+
+    fn emit_u64(v: u64) { ebml::write_vint(self, v) }
+    fn emit_i64(v: u64) { ebml::write_vint(self, v as uint) }
+    fn emit_bool(v: bool) { ebml::write_vint(self, v as uint) }
+    fn emit_f64(v: f64) { fail "float serialization not impl"; }
+    fn emit_str(v: str) {
+        self.wr_tag(es_str as uint) {|| self.wr_str(v) }
+    }
+
+    fn emit_enum(name: str, f: fn()) {
+        self.wr_tag(es_enum as uint) {|| f() }
+    }
+    fn emit_enum_variant(v_name: str, v_id: uint, f: fn()) {
+        self.wr_tag(es_enum_vid as uint) {|| self.write_vint(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.wr_tag(es_vec_len as uint) {|| self.write_vint(len) }
+            f()
+        }
+    }
+
+    fn emit_vec_elt(idx: uint, f: fn()) {
+        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() }
+    }
+
+    fn emit_box(f: fn()) { f() }
+    fn emit_uniq(f: fn()) { f() }
+    fn emit_rec(f: fn()) { f() }
+    fn emit_rec_field(f_name: str, f_idx: uint, f: fn()) { f() }
+    fn emit_tup(sz: uint, f: fn()) { f() }
+    fn emit_tup_elt(idx: uint, f: fn()) { f() }
+}
+
+type ebml_deserializer = {mutable parent: ebml::doc,
+                          mutable pos: uint};
+
+fn mk_ebml_deserializer(d: ebml::doc) -> ebml_deserializer {
+    {mutable parent: d, mutable pos: 0u}
+}
+
+impl of deserializer for ebml_deserializer {
+    fn next_doc(exp_tag: uint) -> ebml::doc {
+        if self.pos >= self.parent.end {
+            fail "no more documents in current node!";
+        }
+        let (r_tag, r_doc) = ebml::doc_at(self.parent.data, self.pos);
+        if r_tag != exp_tag {
+            fail #fmt["expected EMBL doc with tag %u but found tag %u",
+                      exp_tag, r_tag];
+        }
+        if r_doc.end >= self.parent.end {
+            fail #fmt["invalid EBML, child extends to 0x%x, parent to 0x%x",
+                      r_doc.end, self.parent.end];
+        }
+        self.pos = result.end;
+        ret result;
+    }
+
+    fn push_doc<T: copy>(d: ebml::doc, f: fn() -> T) -> T{
+        let old_parent = self.parent;
+        let old_pos = self.pos;
+        self.parent = d;
+        self.pos = 0u;
+        let r = f();
+        self.parent = old_parent;
+        self.pos = old_pos;
+        ret r;
+    }
+
+    fn next_u64(exp_tag: uint) {
+        ebml::doc_as_uint(self.next_doc(exp_tag))
+    }
+
+    fn read_nil() -> () { () }
+    fn read_u64() -> u64 { next_u64(es_u64) }
+    fn read_i64() -> i64 { next_u64(es_u64) as i64 }
+    fn read_bool() -> bool { next_u64(es_u64) as bool }
+    fn read_f64() -> f64 { fail "Float"; }
+    fn read_str() -> str { ebml::doc_str(self.next_doc(es_str)) }
+
+    // Compound types:
+    fn read_enum<T:copy>(name: str, f: fn() -> T) -> T {
+        self.push_doc(self.next_doc(es_enum), f)
+    }
+
+    fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T {
+        let idx = self.next_u64(es_enum_vid);
+        self.push_doc(self.next_doc(es_enum_body)) {||
+            f(idx)
+        }
+    }
+
+    fn read_enum_variant_arg<T:copy>(_idx: uint, f: fn() -> T) -> T {
+        f()
+    }
+
+    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;
+            f(len)
+        }
+    }
+
+    fn read_vec_elt<T:copy>(idx: uint, f: fn() -> T) -> T {
+        self.push_doc(self.next_doc(es_vec_elt), f)
+    }
+
+    fn read_box<T:copy>(f: fn() -> T) -> T {
+        f()
+    }
+
+    fn read_uniq<T:copy>(f: fn() -> T) -> T {
+        f()
+    }
+
+    fn read_rec<T:copy>(f: fn() -> T) -> T {
+        f()
+    }
+
+    fn read_rec_field<T:copy>(f_name: str, f_idx: uint, f: fn() -> T) -> T {
+        f()
+    }
+
+    fn read_tup<T:copy>(sz: uint, f: fn() -> T) -> T {
+        f()
+    }
+
+    fn read_tup_elt<T:copy>(idx: uint, f: fn() -> T) -> T {
+        f()
+    }
+}
+
+// ___________________________________________________________________________
+// Testing
+