From 97cc571358c3ac1bc3d562ac60c39c67cda3678d Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 9 Apr 2013 18:56:34 -0700 Subject: std: clean up the order of {De,En}codable methods --- src/libsyntax/ext/auto_encode.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'src/libsyntax/ext/auto_encode.rs') diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index f9dadb560e3..932c3477cf5 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1253,13 +1253,6 @@ mod test { self.add_to_log(CallToEmitEnumVariantArg (idx)); f(); } - fn emit_seq(&self, +_len: uint, f: &fn()) { - self.add_unknown_to_log(); f(); - } - fn emit_seq_elt(&self, +_idx: uint, f: &fn()) { - self.add_unknown_to_log(); f(); - } - fn emit_struct(&self, name: &str, +len: uint, f: &fn()) { self.add_to_log(CallToEmitStruct (name.to_str(),len)); f(); } @@ -1279,6 +1272,13 @@ mod test { f(); } + fn emit_seq(&self, +_len: uint, f: &fn()) { + self.add_unknown_to_log(); f(); + } + fn emit_seq_elt(&self, +_idx: uint, f: &fn()) { + self.add_unknown_to_log(); f(); + } + fn emit_map(&self, _len: uint, f: &fn()) { self.add_unknown_to_log(); f(); } -- cgit 1.4.1-3-g733a5 From 419f6acf0e609c18c6df5ee2ca8ed9cb6206bbfe Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 9 Apr 2013 19:41:20 -0700 Subject: std: rename {read,emit}_field to {read,emit}_struct_field --- src/librustc/middle/astencode.rs | 97 ++++++++++++++++++++++++++++++++++++++++ src/libstd/ebml.rs | 20 ++++++++- src/libstd/json.rs | 50 ++++++++++++++++++++- src/libstd/serialize.rs | 16 +++++-- src/libsyntax/ext/auto_encode.rs | 10 ++--- 5 files changed, 183 insertions(+), 10 deletions(-) (limited to 'src/libsyntax/ext/auto_encode.rs') diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 68989b31425..f5a31879855 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -556,6 +556,7 @@ trait read_method_map_entry_helper { -> method_map_entry; } +#[cfg(stage0)] fn encode_method_map_entry(ecx: @e::EncodeContext, ebml_w: writer::Encoder, mme: method_map_entry) { @@ -572,7 +573,27 @@ fn encode_method_map_entry(ecx: @e::EncodeContext, } } +#[cfg(stage1)] +#[cfg(stage2)] +#[cfg(stage3)] +fn encode_method_map_entry(ecx: @e::EncodeContext, + ebml_w: writer::Encoder, + mme: method_map_entry) { + do ebml_w.emit_struct("method_map_entry", 3) { + do ebml_w.emit_struct_field("self_arg", 0u) { + ebml_w.emit_arg(ecx, mme.self_arg); + } + do ebml_w.emit_struct_field("explicit_self", 2u) { + mme.explicit_self.encode(&ebml_w); + } + do ebml_w.emit_struct_field("origin", 1u) { + mme.origin.encode(&ebml_w); + } + } +} + impl read_method_map_entry_helper for reader::Decoder { + #[cfg(stage0)] fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext) -> method_map_entry { do self.read_struct("method_map_entry", 3) { @@ -592,6 +613,29 @@ impl read_method_map_entry_helper for reader::Decoder { } } } + + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext) + -> method_map_entry { + do self.read_struct("method_map_entry", 3) { + method_map_entry { + self_arg: self.read_struct_field("self_arg", 0u, || { + self.read_arg(xcx) + }), + explicit_self: self.read_struct_field("explicit_self", 2u, || { + let self_type: ast::self_ty_ = Decodable::decode(self); + self_type + }), + origin: self.read_struct_field("origin", 1u, || { + let method_origin: method_origin = + Decodable::decode(self); + method_origin.tr(xcx) + }), + } + } + } } impl tr for method_origin { @@ -782,6 +826,7 @@ impl ebml_writer_helpers for writer::Encoder { } } + #[cfg(stage0)] fn emit_tpbt(&self, ecx: @e::EncodeContext, tpbt: ty::ty_param_bounds_and_ty) { do self.emit_struct("ty_param_bounds_and_ty", 2) { @@ -804,6 +849,32 @@ impl ebml_writer_helpers for writer::Encoder { } } } + + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn emit_tpbt(&self, ecx: @e::EncodeContext, + tpbt: ty::ty_param_bounds_and_ty) { + do self.emit_struct("ty_param_bounds_and_ty", 2) { + do self.emit_struct_field("generics", 0) { + do self.emit_struct("Generics", 2) { + do self.emit_struct_field("type_param_defs", 0) { + do self.emit_from_vec(*tpbt.generics.type_param_defs) + |type_param_def| + { + self.emit_type_param_def(ecx, type_param_def); + } + } + do self.emit_struct_field("region_param", 1) { + tpbt.generics.region_param.encode(self); + } + } + } + do self.emit_struct_field("ty", 1) { + self.emit_ty(ecx, tpbt.ty); + } + } + } } trait write_tag_and_id { @@ -1053,6 +1124,7 @@ impl ebml_decoder_decoder_helpers for reader::Decoder { } } + #[cfg(stage0)] fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext) -> ty::ty_param_bounds_and_ty { @@ -1075,6 +1147,31 @@ impl ebml_decoder_decoder_helpers for reader::Decoder { } } + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext) + -> ty::ty_param_bounds_and_ty + { + do self.read_struct("ty_param_bounds_and_ty", 2) { + ty::ty_param_bounds_and_ty { + generics: do self.read_struct("Generics", 2) { + ty::Generics { + type_param_defs: self.read_struct_field("type_param_defs", 0, || { + @self.read_to_vec(|| self.read_type_param_def(xcx)) + }), + region_param: self.read_struct_field(~"region_param", 1, || { + Decodable::decode(self) + }) + } + }, + ty: self.read_struct_field("ty", 1, || { + self.read_ty(xcx) + }) + } + } + } + fn convert_def_id(&self, xcx: @ExtendedDecodeContext, source: tydecode::DefIdSource, did: ast::def_id) -> ast::def_id { diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 3afc49d40ad..28933d553e6 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -340,8 +340,18 @@ pub mod reader { f() } + #[cfg(stage0)] fn read_field(&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(&self, name: &str, idx: uint, f: &fn() -> T) -> T { + debug!("read_struct_field(name=%?, idx=%u)", name, idx); self._check_label(name); f() } @@ -614,10 +624,18 @@ pub mod writer { fn emit_enum_variant_arg(&self, _idx: uint, f: &fn()) { 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_option(&self, f: &fn()) { self.emit_enum("Option", f); diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 3714adb3055..4b5e1f14229 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -135,12 +135,22 @@ 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_option(&self, f: &fn()) { f(); } fn emit_option_none(&self) { self.emit_nil(); } @@ -254,6 +264,7 @@ impl serialize::Encoder for PrettyEncoder { self.wr.write_char('}'); } } + #[cfg(stage0)] fn emit_field(&self, name: &str, idx: uint, f: &fn()) { if idx == 0 { self.wr.write_char('\n'); @@ -265,6 +276,20 @@ impl serialize::Encoder for PrettyEncoder { 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_option(&self, f: &fn()) { f(); } fn emit_option_none(&self) { self.emit_nil(); } @@ -834,8 +859,31 @@ impl serialize::Decoder for Decoder { value } + #[cfg(stage0)] fn read_field(&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; + 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)) + } + } + + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_struct_field(&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; diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index a49f43d485b..cc3a1ec0289 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -48,8 +48,13 @@ pub trait Encoder { 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_struct(&self, name: &str, _len: 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()); // Specialized types: fn emit_option(&self, f: &fn()); @@ -89,8 +94,13 @@ pub trait Decoder { fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T; fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T; - fn read_struct(&self, name: &str, _len: uint, f: &fn() -> T) -> T; - fn read_field(&self, name: &str, idx: uint, f: &fn() -> T) -> T; + fn read_struct(&self, s_name: &str, len: uint, f: &fn() -> T) -> T; + #[cfg(stage0)] + fn read_field(&self, f_name: &str, f_idx: uint, f: &fn() -> T) -> T; + #[cfg(stage1)] + #[cfg(stage2)] + #[cfg(stage3)] + fn read_struct_field(&self, f_name: &str, f_idx: uint, f: &fn() -> T) -> T; // Specialized types: fn read_option(&self, f: &fn(bool) -> T) -> T; diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 932c3477cf5..38bac6b1f43 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -732,12 +732,12 @@ fn mk_struct_ser_impl( ) ); - // ast for `__s.emit_field($(name), $(idx), $(expr_lambda))` + // ast for `__s.emit_struct_field($(name), $(idx), $(expr_lambda))` cx.stmt( cx.expr_method_call( span, cx.expr_var(span, ~"__s"), - cx.ident_of(~"emit_field"), + cx.ident_of(~"emit_struct_field"), ~[ cx.lit_str(span, @cx.str_of(field.ident)), cx.lit_uint(span, idx), @@ -786,11 +786,11 @@ fn mk_struct_deser_impl( ) ); - // ast for `__d.read_field($(name), $(idx), $(expr_lambda))` + // ast for `__d.read_struct_field($(name), $(idx), $(expr_lambda))` let expr: @ast::expr = cx.expr_method_call( span, cx.expr_var(span, ~"__d"), - cx.ident_of(~"read_field"), + cx.ident_of(~"read_struct_field"), ~[ cx.lit_str(span, @cx.str_of(field.ident)), cx.lit_uint(span, idx), @@ -1256,7 +1256,7 @@ mod test { fn emit_struct(&self, name: &str, +len: uint, f: &fn()) { self.add_to_log(CallToEmitStruct (name.to_str(),len)); f(); } - fn emit_field(&self, name: &str, +idx: uint, f: &fn()) { + fn emit_struct_field(&self, name: &str, +idx: uint, f: &fn()) { self.add_to_log(CallToEmitField (name.to_str(),idx)); f(); } -- cgit 1.4.1-3-g733a5 From e31f7b7c74f54cc80f908dc074f3efb95e5b36d5 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 9 Apr 2013 19:44:12 -0700 Subject: std: add serialize {read,emit}_tuple{,_arg,_struct,_struct_arg} --- src/libstd/ebml.rs | 26 ++++++++++++++++++++++++++ src/libstd/json.rs | 32 ++++++++++++++++++++++++++++++++ src/libstd/serialize.rs | 12 ++++++++++++ src/libsyntax/ext/auto_encode.rs | 14 ++++++++++++++ 4 files changed, 84 insertions(+) (limited to 'src/libsyntax/ext/auto_encode.rs') diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 28933d553e6..a7a6e827feb 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -356,6 +356,26 @@ pub mod reader { f() } + fn read_tuple(&self, f: &fn(uint) -> T) -> T { + debug!("read_tuple()"); + self.read_seq(f) + } + + fn read_tuple_arg(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_tuple_arg(idx=%u)", idx); + self.read_seq_elt(idx, f) + } + + fn read_tuple_struct(&self, name: &str, f: &fn(uint) -> T) -> T { + debug!("read_tuple_struct(name=%?)", name); + self.read_tuple(f) + } + + fn read_tuple_struct_arg(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_tuple_struct_arg(idx=%u)", idx); + self.read_tuple_arg(idx, f) + } + fn read_option(&self, f: &fn(bool) -> T) -> T { debug!("read_option()"); do self.read_enum("Option") || { @@ -637,6 +657,12 @@ pub mod writer { 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); } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 4b5e1f14229..658a6ce281f 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -152,6 +152,12 @@ impl serialize::Encoder for Encoder { 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(); } @@ -291,6 +297,12 @@ impl serialize::Encoder for PrettyEncoder { 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(); } @@ -901,6 +913,26 @@ impl serialize::Decoder for Decoder { } } + fn read_tuple(&self, f: &fn(uint) -> T) -> T { + debug!("read_tuple()"); + self.read_seq(f) + } + + fn read_tuple_arg(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_tuple_arg(idx=%u)", idx); + self.read_seq_elt(idx, f) + } + + fn read_tuple_struct(&self, name: &str, f: &fn(uint) -> T) -> T { + debug!("read_tuple_struct(name=%?)", name); + self.read_tuple(f) + } + + fn read_tuple_struct_arg(&self, idx: uint, f: &fn() -> T) -> T { + debug!("read_tuple_struct_arg(idx=%u)", idx); + self.read_tuple_arg(idx, f) + } + fn read_option(&self, f: &fn(bool) -> T) -> T { match self.stack.pop() { Null => f(false), diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index cc3a1ec0289..2a685b2f1d6 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -56,6 +56,12 @@ pub trait Encoder { #[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); @@ -102,6 +108,12 @@ pub trait Decoder { #[cfg(stage3)] fn read_struct_field(&self, f_name: &str, f_idx: uint, f: &fn() -> T) -> T; + fn read_tuple(&self, f: &fn(uint) -> T) -> T; + fn read_tuple_arg(&self, a_idx: uint, f: &fn() -> T) -> T; + + fn read_tuple_struct(&self, s_name: &str, f: &fn(uint) -> T) -> T; + fn read_tuple_struct_arg(&self, a_idx: uint, f: &fn() -> T) -> T; + // Specialized types: fn read_option(&self, f: &fn(bool) -> T) -> T; diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 38bac6b1f43..287c2d7ba84 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1260,6 +1260,20 @@ mod test { self.add_to_log(CallToEmitField (name.to_str(),idx)); f(); } + fn emit_tuple(&self, _len: uint, f: &fn()) { + self.add_unknown_to_log(); f(); + } + fn emit_tuple_arg(&self, _idx: uint, f: &fn()) { + self.add_unknown_to_log(); f(); + } + + fn emit_tuple_struct(&self, _name: &str, _len: uint, f: &fn()) { + self.add_unknown_to_log(); f(); + } + fn emit_tuple_struct_arg(&self, _idx: uint, f: &fn()) { + self.add_unknown_to_log(); f(); + } + fn emit_option(&self, f: &fn()) { self.add_to_log(CallToEmitOption); f(); -- cgit 1.4.1-3-g733a5 From f3ab67ec5f75fc3376e5647dfb7e5b46a535dea7 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 9 Apr 2013 19:45:10 -0700 Subject: syntax: add {read,emit}_enum_struct_variant{,_field} --- src/libstd/ebml.rs | 24 ++++++++++++++++++++++++ src/libstd/json.rs | 33 ++++++++++++++++++++++++++++++++- src/libstd/serialize.rs | 14 +++++++++++--- src/libsyntax/ext/auto_encode.rs | 8 ++++++++ 4 files changed, 75 insertions(+), 4 deletions(-) (limited to 'src/libsyntax/ext/auto_encode.rs') diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index a7a6e827feb..4a3447700bc 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -335,6 +335,20 @@ pub mod reader { f() } + fn read_enum_struct_variant(&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_enum_struct_variant_field(&self, name: &str, idx: uint, f: &fn() -> T) -> T { + debug!("read_enum_struct_variant_arg(name=%?, idx=%u)", name, idx); + f() + } + fn read_struct(&self, name: &str, _len: uint, f: &fn() -> T) -> T { debug!("read_struct(name=%s)", name); f() @@ -636,13 +650,23 @@ 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_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_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()) { diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 658a6ce281f..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,10 +127,18 @@ 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_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()) { self.wr.write_char('{'); f(); @@ -232,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)); @@ -249,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"); @@ -257,6 +268,15 @@ impl serialize::Encoder for PrettyEncoder { f() } + 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("{}"); @@ -864,6 +884,17 @@ impl serialize::Decoder for Decoder { f() } + fn read_enum_struct_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T { + debug!("read_enum_struct_variant(names=%?)", names); + self.read_enum_variant(names, f) + } + + + fn read_enum_struct_variant_field(&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(&self, name: &str, len: uint, f: &fn() -> T) -> T { debug!("read_struct(name=%s, len=%u)", name, len); let value = f(); diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 2a685b2f1d6..68ae9a66417 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -45,8 +45,12 @@ pub trait Encoder { // 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_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_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)] @@ -97,8 +101,12 @@ pub trait Decoder { // Compound types: fn read_enum(&self, name: &str, f: &fn() -> T) -> T; + fn read_enum_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T; - fn read_enum_variant_arg(&self, idx: uint, f: &fn() -> T) -> T; + fn read_enum_variant_arg(&self, a_idx: uint, f: &fn() -> T) -> T; + + fn read_enum_struct_variant(&self, names: &[&str], f: &fn(uint) -> T) -> T; + fn read_enum_struct_variant_field(&self, &f_name: &str, f_idx: uint, f: &fn() -> T) -> T; fn read_struct(&self, s_name: &str, len: uint, f: &fn() -> T) -> T; #[cfg(stage0)] diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index 287c2d7ba84..e53a8f361b5 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -1253,6 +1253,14 @@ mod test { self.add_to_log(CallToEmitEnumVariantArg (idx)); f(); } + 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, _name: &str, idx: uint, f: &fn()) { + self.emit_enum_variant_arg(idx, f) + } + fn emit_struct(&self, name: &str, +len: uint, f: &fn()) { self.add_to_log(CallToEmitStruct (name.to_str(),len)); f(); } -- cgit 1.4.1-3-g733a5