about summary refs log tree commit diff
path: root/src/libstd
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd')
-rw-r--r--src/libstd/ebml.rs102
-rw-r--r--src/libstd/json.rs197
-rw-r--r--src/libstd/serialize.rs51
3 files changed, 279 insertions, 71 deletions
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index b117c8d9882..4a3447700bc 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -335,18 +335,18 @@ pub mod reader {
             f()
         }
 
-        fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
-            debug!("read_seq()");
-            do self.push_doc(self.next_doc(EsVec)) {
-                let len = self._next_uint(EsVecLen);
-                debug!("  len=%u", len);
-                f(len)
+        fn read_enum_struct_variant<T>(&self, _names: &[&str], f: &fn(uint) -> T) -> T {
+            debug!("read_enum_struct_variant()");
+            let idx = self._next_uint(EsEnumVid);
+            debug!("  idx=%u", idx);
+            do self.push_doc(self.next_doc(EsEnumBody)) {
+                f(idx)
             }
         }
 
-        fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
-            debug!("read_seq_elt(idx=%u)", idx);
-            self.push_doc(self.next_doc(EsVecElt), f)
+        fn read_enum_struct_variant_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
+            debug!("read_enum_struct_variant_arg(name=%?, idx=%u)", name, idx);
+            f()
         }
 
         fn read_struct<T>(&self, name: &str, _len: uint, f: &fn() -> T) -> T {
@@ -354,12 +354,42 @@ pub mod reader {
             f()
         }
 
+        #[cfg(stage0)]
         fn read_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
-            debug!("read_field(name=%s, idx=%u)", name, idx);
+            debug!("read_field(name=%?, idx=%u)", name, idx);
             self._check_label(name);
             f()
         }
 
+        #[cfg(stage1)]
+        #[cfg(stage2)]
+        #[cfg(stage3)]
+        fn read_struct_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
+            debug!("read_struct_field(name=%?, idx=%u)", name, idx);
+            self._check_label(name);
+            f()
+        }
+
+        fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T {
+            debug!("read_tuple()");
+            self.read_seq(f)
+        }
+
+        fn read_tuple_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
+            debug!("read_tuple_arg(idx=%u)", idx);
+            self.read_seq_elt(idx, f)
+        }
+
+        fn read_tuple_struct<T>(&self, name: &str, f: &fn(uint) -> T) -> T {
+            debug!("read_tuple_struct(name=%?)", name);
+            self.read_tuple(f)
+        }
+
+        fn read_tuple_struct_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
+            debug!("read_tuple_struct_arg(idx=%u)", idx);
+            self.read_tuple_arg(idx, f)
+        }
+
         fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
             debug!("read_option()");
             do self.read_enum("Option") || {
@@ -373,6 +403,20 @@ pub mod reader {
             }
         }
 
+        fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
+            debug!("read_seq()");
+            do self.push_doc(self.next_doc(EsVec)) {
+                let len = self._next_uint(EsVecLen);
+                debug!("  len=%u", len);
+                f(len)
+            }
+        }
+
+        fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
+            debug!("read_seq_elt(idx=%u)", idx);
+            self.push_doc(self.next_doc(EsVecElt), f)
+        }
+
         fn read_map<T>(&self, _f: &fn(uint) -> T) -> T {
             debug!("read_map()");
             fail!(~"read_map is unimplemented");
@@ -606,29 +650,42 @@ pub mod writer {
             self._emit_label(name);
             self.wr_tag(EsEnum as uint, f)
         }
+
         fn emit_enum_variant(&self, _v_name: &str, v_id: uint, _cnt: uint,
                              f: &fn()) {
             self._emit_tagged_uint(EsEnumVid, v_id);
             self.wr_tag(EsEnumBody as uint, f)
         }
+
         fn emit_enum_variant_arg(&self, _idx: uint, f: &fn()) { f() }
 
-        fn emit_seq(&self, len: uint, f: &fn()) {
-            do self.wr_tag(EsVec as uint) {
-                self._emit_tagged_uint(EsVecLen, len);
-                f()
-            }
+        fn emit_enum_struct_variant(&self, v_name: &str, v_id: uint, cnt: uint, f: &fn()) {
+            self.emit_enum_variant(v_name, v_id, cnt, f)
         }
 
-        fn emit_seq_elt(&self, _idx: uint, f: &fn()) {
-            self.wr_tag(EsVecElt as uint, f)
+        fn emit_enum_struct_variant_field(&self, _f_name: &str, idx: uint, f: &fn()) {
+            self.emit_enum_variant_arg(idx, f)
         }
 
         fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) { f() }
+        #[cfg(stage0)]
         fn emit_field(&self, name: &str, _idx: uint, f: &fn()) {
             self._emit_label(name);
             f()
         }
+        #[cfg(stage1)]
+        #[cfg(stage2)]
+        #[cfg(stage3)]
+        fn emit_struct_field(&self, name: &str, _idx: uint, f: &fn()) {
+            self._emit_label(name);
+            f()
+        }
+
+        fn emit_tuple(&self, len: uint, f: &fn()) { self.emit_seq(len, f) }
+        fn emit_tuple_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
+
+        fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) { self.emit_seq(len, f) }
+        fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
 
         fn emit_option(&self, f: &fn()) {
             self.emit_enum("Option", f);
@@ -640,6 +697,17 @@ pub mod writer {
             self.emit_enum_variant("Some", 1, 1, f)
         }
 
+        fn emit_seq(&self, len: uint, f: &fn()) {
+            do self.wr_tag(EsVec as uint) {
+                self._emit_tagged_uint(EsVecLen, len);
+                f()
+            }
+        }
+
+        fn emit_seq_elt(&self, _idx: uint, f: &fn()) {
+            self.wr_tag(EsVecElt as uint, f)
+        }
+
         fn emit_map(&self, _len: uint, _f: &fn()) {
             fail!(~"emit_map is unimplemented");
         }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 90a745aaeb9..f5cd8b4bd68 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -109,6 +109,7 @@ impl serialize::Encoder for Encoder {
     fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)) }
 
     fn emit_enum(&self, _name: &str, f: &fn()) { f() }
+
     fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) {
         // enums are encoded as strings or vectors:
         // Bunny => "Bunny"
@@ -126,19 +127,16 @@ impl serialize::Encoder for Encoder {
     }
 
     fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
-        if (idx != 0) {self.wr.write_char(',');}
+        if idx != 0 {self.wr.write_char(',');}
         f();
     }
 
-    fn emit_seq(&self, _len: uint, f: &fn()) {
-        self.wr.write_char('[');
-        f();
-        self.wr.write_char(']');
+    fn emit_enum_struct_variant(&self, name: &str, id: uint, cnt: uint, f: &fn()) {
+        self.emit_enum_variant(name, id, cnt, f)
     }
 
-    fn emit_seq_elt(&self, idx: uint, f: &fn()) {
-        if idx != 0 { self.wr.write_char(','); }
-        f()
+    fn emit_enum_struct_variant_field(&self, _field: &str, idx: uint, f: &fn()) {
+        self.emit_enum_variant_arg(idx, f)
     }
 
     fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) {
@@ -146,17 +144,44 @@ impl serialize::Encoder for Encoder {
         f();
         self.wr.write_char('}');
     }
+    #[cfg(stage0)]
     fn emit_field(&self, name: &str, idx: uint, f: &fn()) {
         if idx != 0 { self.wr.write_char(','); }
         self.wr.write_str(escape_str(name));
         self.wr.write_char(':');
         f();
     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn emit_struct_field(&self, name: &str, idx: uint, f: &fn()) {
+        if idx != 0 { self.wr.write_char(','); }
+        self.wr.write_str(escape_str(name));
+        self.wr.write_char(':');
+        f();
+    }
+
+    fn emit_tuple(&self, len: uint, f: &fn()) { self.emit_seq(len, f) }
+    fn emit_tuple_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
+
+    fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) { self.emit_seq(len, f) }
+    fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
 
     fn emit_option(&self, f: &fn()) { f(); }
     fn emit_option_none(&self) { self.emit_nil(); }
     fn emit_option_some(&self, f: &fn()) { f(); }
 
+    fn emit_seq(&self, _len: uint, f: &fn()) {
+        self.wr.write_char('[');
+        f();
+        self.wr.write_char(']');
+    }
+
+    fn emit_seq_elt(&self, idx: uint, f: &fn()) {
+        if idx != 0 { self.wr.write_char(','); }
+        f()
+    }
+
     fn emit_map(&self, _len: uint, f: &fn()) {
         self.wr.write_char('{');
         f();
@@ -216,6 +241,7 @@ impl serialize::Encoder for PrettyEncoder {
     fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)); }
 
     fn emit_enum(&self, _name: &str, f: &fn()) { f() }
+
     fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) {
         if cnt == 0 {
             self.wr.write_str(escape_str(name));
@@ -233,6 +259,7 @@ impl serialize::Encoder for PrettyEncoder {
             self.wr.write_char(']');
         }
     }
+
     fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
         if idx != 0 {
             self.wr.write_str(",\n");
@@ -241,58 +268,88 @@ impl serialize::Encoder for PrettyEncoder {
         f()
     }
 
-    fn emit_seq(&self, len: uint, f: &fn()) {
+    fn emit_enum_struct_variant(&self, name: &str, id: uint, cnt: uint, f: &fn()) {
+        self.emit_enum_variant(name, id, cnt, f)
+    }
+
+    fn emit_enum_struct_variant_field(&self, _field: &str, idx: uint, f: &fn()) {
+        self.emit_enum_variant_arg(idx, f)
+    }
+
+
+    fn emit_struct(&self, _name: &str, len: uint, f: &fn()) {
         if len == 0 {
-            self.wr.write_str("[]");
+            self.wr.write_str("{}");
         } else {
-            self.wr.write_char('[');
+            self.wr.write_char('{');
             self.indent += 2;
             f();
             self.wr.write_char('\n');
             self.indent -= 2;
             self.wr.write_str(spaces(self.indent));
-            self.wr.write_char(']');
+            self.wr.write_char('}');
         }
     }
-    fn emit_seq_elt(&self, idx: uint, f: &fn()) {
+    #[cfg(stage0)]
+    fn emit_field(&self, name: &str, idx: uint, f: &fn()) {
         if idx == 0 {
             self.wr.write_char('\n');
         } else {
             self.wr.write_str(",\n");
         }
         self.wr.write_str(spaces(self.indent));
-        f()
+        self.wr.write_str(escape_str(name));
+        self.wr.write_str(": ");
+        f();
+    }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn emit_struct_field(&self, name: &str, idx: uint, f: &fn()) {
+        if idx == 0 {
+            self.wr.write_char('\n');
+        } else {
+            self.wr.write_str(",\n");
+        }
+        self.wr.write_str(spaces(self.indent));
+        self.wr.write_str(escape_str(name));
+        self.wr.write_str(": ");
+        f();
     }
 
-    fn emit_struct(&self, _name: &str, len: uint, f: &fn()) {
+    fn emit_tuple(&self, len: uint, f: &fn()) { self.emit_seq(len, f) }
+    fn emit_tuple_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
+
+    fn emit_tuple_struct(&self, _name: &str, len: uint, f: &fn()) { self.emit_seq(len, f) }
+    fn emit_tuple_struct_arg(&self, idx: uint, f: &fn()) { self.emit_seq_elt(idx, f) }
+
+    fn emit_option(&self, f: &fn()) { f(); }
+    fn emit_option_none(&self) { self.emit_nil(); }
+    fn emit_option_some(&self, f: &fn()) { f(); }
+
+    fn emit_seq(&self, len: uint, f: &fn()) {
         if len == 0 {
-            self.wr.write_str("{}");
+            self.wr.write_str("[]");
         } else {
-            self.wr.write_char('{');
+            self.wr.write_char('[');
             self.indent += 2;
             f();
             self.wr.write_char('\n');
             self.indent -= 2;
             self.wr.write_str(spaces(self.indent));
-            self.wr.write_char('}');
+            self.wr.write_char(']');
         }
     }
-    fn emit_field(&self, name: &str, idx: uint, f: &fn()) {
+    fn emit_seq_elt(&self, idx: uint, f: &fn()) {
         if idx == 0 {
             self.wr.write_char('\n');
         } else {
             self.wr.write_str(",\n");
         }
         self.wr.write_str(spaces(self.indent));
-        self.wr.write_str(escape_str(name));
-        self.wr.write_str(": ");
-        f();
+        f()
     }
 
-    fn emit_option(&self, f: &fn()) { f(); }
-    fn emit_option_none(&self) { self.emit_nil(); }
-    fn emit_option_some(&self, f: &fn()) { f(); }
-
     fn emit_map(&self, len: uint, f: &fn()) {
         if len == 0 {
             self.wr.write_str("{}");
@@ -827,24 +884,15 @@ impl serialize::Decoder for Decoder {
         f()
     }
 
-    fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
-        debug!("read_seq()");
-        let len = match self.stack.pop() {
-            List(list) => {
-                let len = list.len();
-                do vec::consume_reverse(list) |_i, v| {
-                    self.stack.push(v);
-                }
-                len
-            }
-            _ => fail!(~"not a list"),
-        };
-        f(len)
+    fn read_enum_struct_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T {
+        debug!("read_enum_struct_variant(names=%?)", names);
+        self.read_enum_variant(names, f)
     }
 
-    fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
-        debug!("read_seq_elt(idx=%u)", idx);
-        f()
+
+    fn read_enum_struct_variant_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
+        debug!("read_enum_struct_variant_field(name=%?, idx=%u)", name, idx);
+        self.read_enum_variant_arg(idx, f)
     }
 
     fn read_struct<T>(&self, name: &str, len: uint, f: &fn() -> T) -> T {
@@ -854,8 +902,9 @@ impl serialize::Decoder for Decoder {
         value
     }
 
+    #[cfg(stage0)]
     fn read_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
-        debug!("read_field(%s, idx=%u)", name, idx);
+        debug!("read_field(name=%?, idx=%u)", name, idx);
         match self.stack.pop() {
             Object(obj) => {
                 let mut obj = obj;
@@ -873,6 +922,48 @@ impl serialize::Decoder for Decoder {
         }
     }
 
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn read_struct_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
+        debug!("read_struct_field(name=%?, idx=%u)", name, idx);
+        match self.stack.pop() {
+            Object(obj) => {
+                let mut obj = obj;
+                let value = match obj.pop(&name.to_owned()) {
+                    None => fail!(fmt!("no such field: %s", name)),
+                    Some(json) => {
+                        self.stack.push(json);
+                        f()
+                    }
+                };
+                self.stack.push(Object(obj));
+                value
+            }
+            value => fail!(fmt!("not an object: %?", value))
+        }
+    }
+
+    fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T {
+        debug!("read_tuple()");
+        self.read_seq(f)
+    }
+
+    fn read_tuple_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
+        debug!("read_tuple_arg(idx=%u)", idx);
+        self.read_seq_elt(idx, f)
+    }
+
+    fn read_tuple_struct<T>(&self, name: &str, f: &fn(uint) -> T) -> T {
+        debug!("read_tuple_struct(name=%?)", name);
+        self.read_tuple(f)
+    }
+
+    fn read_tuple_struct_arg<T>(&self, idx: uint, f: &fn() -> T) -> T {
+        debug!("read_tuple_struct_arg(idx=%u)", idx);
+        self.read_tuple_arg(idx, f)
+    }
+
     fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
         match self.stack.pop() {
             Null => f(false),
@@ -880,6 +971,26 @@ impl serialize::Decoder for Decoder {
         }
     }
 
+    fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
+        debug!("read_seq()");
+        let len = match self.stack.pop() {
+            List(list) => {
+                let len = list.len();
+                do vec::consume_reverse(list) |_i, v| {
+                    self.stack.push(v);
+                }
+                len
+            }
+            _ => fail!(~"not a list"),
+        };
+        f(len)
+    }
+
+    fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
+        debug!("read_seq_elt(idx=%u)", idx);
+        f()
+    }
+
     fn read_map<T>(&self, f: &fn(uint) -> T) -> T {
         debug!("read_map()");
         let len = match self.stack.pop() {
diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs
index c2f0d9cb43f..68ae9a66417 100644
--- a/src/libstd/serialize.rs
+++ b/src/libstd/serialize.rs
@@ -44,22 +44,36 @@ pub trait Encoder {
     fn emit_str(&self, v: &str);
 
     // Compound types:
-
     fn emit_enum(&self, name: &str, f: &fn());
-    fn emit_enum_variant(&self, v_name: &str, v_id: uint, sz: uint, f: &fn());
-    fn emit_enum_variant_arg(&self, idx: uint, f: &fn());
 
-    fn emit_seq(&self, len: uint, f: &fn());
-    fn emit_seq_elt(&self, idx: uint, f: &fn());
+    fn emit_enum_variant(&self, v_name: &str, v_id: uint, len: uint, f: &fn());
+    fn emit_enum_variant_arg(&self, a_idx: uint, f: &fn());
 
-    fn emit_struct(&self, name: &str, _len: uint, f: &fn());
+    fn emit_enum_struct_variant(&self, v_name: &str, v_id: uint, len: uint, f: &fn());
+    fn emit_enum_struct_variant_field(&self, f_name: &str, f_idx: uint, f: &fn());
+
+    fn emit_struct(&self, name: &str, len: uint, f: &fn());
+    #[cfg(stage0)]
     fn emit_field(&self, f_name: &str, f_idx: uint, f: &fn());
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn emit_struct_field(&self, f_name: &str, f_idx: uint, f: &fn());
+
+    fn emit_tuple(&self, len: uint, f: &fn());
+    fn emit_tuple_arg(&self, idx: uint, f: &fn());
+
+    fn emit_tuple_struct(&self, name: &str, len: uint, f: &fn());
+    fn emit_tuple_struct_arg(&self, f_idx: uint, f: &fn());
 
     // Specialized types:
     fn emit_option(&self, f: &fn());
     fn emit_option_none(&self);
     fn emit_option_some(&self, f: &fn());
 
+    fn emit_seq(&self, len: uint, f: &fn());
+    fn emit_seq_elt(&self, idx: uint, f: &fn());
+
     fn emit_map(&self, len: uint, f: &fn());
     fn emit_map_elt_key(&self, idx: uint, f: &fn());
     fn emit_map_elt_val(&self, idx: uint, f: &fn());
@@ -87,18 +101,33 @@ pub trait Decoder {
 
     // Compound types:
     fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T;
+
     fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T;
-    fn read_enum_variant_arg<T>(&self, idx: uint, f: &fn() -> T) -> T;
+    fn read_enum_variant_arg<T>(&self, a_idx: uint, f: &fn() -> T) -> T;
 
-    fn read_seq<T>(&self, f: &fn(uint) -> T) -> T;
-    fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T;
+    fn read_enum_struct_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T;
+    fn read_enum_struct_variant_field<T>(&self, &f_name: &str, f_idx: uint, f: &fn() -> T) -> T;
+
+    fn read_struct<T>(&self, s_name: &str, len: uint, f: &fn() -> T) -> T;
+    #[cfg(stage0)]
+    fn read_field<T>(&self, f_name: &str, f_idx: uint, f: &fn() -> T) -> T;
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
+    fn read_struct_field<T>(&self, f_name: &str, f_idx: uint, f: &fn() -> T) -> T;
 
-    fn read_struct<T>(&self, name: &str, _len: uint, f: &fn() -> T) -> T;
-    fn read_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T;
+    fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T;
+    fn read_tuple_arg<T>(&self, a_idx: uint, f: &fn() -> T) -> T;
+
+    fn read_tuple_struct<T>(&self, s_name: &str, f: &fn(uint) -> T) -> T;
+    fn read_tuple_struct_arg<T>(&self, a_idx: uint, f: &fn() -> T) -> T;
 
     // Specialized types:
     fn read_option<T>(&self, f: &fn(bool) -> T) -> T;
 
+    fn read_seq<T>(&self, f: &fn(uint) -> T) -> T;
+    fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T;
+
     fn read_map<T>(&self, f: &fn(uint) -> T) -> T;
     fn read_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T;
     fn read_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T;
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-03-28 23:42:31 +0000