f()
}
+ 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_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 {
debug!("read_struct(name=%s)", name);
f()
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()) {
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"
}
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();
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));
self.wr.write_char(']');
}
}
+
fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
if idx != 0 {
self.wr.write_str(",\n");
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("{}");
f()
}
+ 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_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 {
debug!("read_struct(name=%s, len=%u)", name, len);
let value = f();
// 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)]
// 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_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)]
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();
}