1 files changed, 44 insertions, 30 deletions
diff --git a/src/pkg/gob/encoder.go b/src/pkg/gob/encoder.go
index 8869b2629..29ba44057 100644
--- a/src/pkg/gob/encoder.go
+++ b/src/pkg/gob/encoder.go
@@ -16,9 +16,8 @@ import (
 // other side of a connection.
 type Encoder struct {
 	mutex      sync.Mutex              // each item must be sent atomically
-	w          io.Writer               // where to send the data
+	w          []io.Writer             // where to send the data
 	sent       map[reflect.Type]typeId // which types we've already sent
-	state      *encoderState           // so we can encode integers, strings directly
 	countState *encoderState           // stage for writing counts
 	buf        []byte                  // for collecting the output.
 	err        os.Error
@@ -27,13 +26,27 @@ type Encoder struct {
 // NewEncoder returns a new encoder that will transmit on the io.Writer.
 func NewEncoder(w io.Writer) *Encoder {
 	enc := new(Encoder)
-	enc.w = w
+	enc.w = []io.Writer{w}
 	enc.sent = make(map[reflect.Type]typeId)
-	enc.state = newEncoderState(enc, new(bytes.Buffer))
 	enc.countState = newEncoderState(enc, new(bytes.Buffer))
 	return enc
 }
 
+// writer() returns the innermost writer the encoder is using
+func (enc *Encoder) writer() io.Writer {
+	return enc.w[len(enc.w)-1]
+}
+
+// pushWriter adds a writer to the encoder.
+func (enc *Encoder) pushWriter(w io.Writer) {
+	enc.w = append(enc.w, w)
+}
+
+// popWriter pops the innermost writer.
+func (enc *Encoder) popWriter() {
+	enc.w = enc.w[0 : len(enc.w)-1]
+}
+
 func (enc *Encoder) badType(rt reflect.Type) {
 	enc.setError(os.ErrorString("gob: can't encode type " + rt.String()))
 }
@@ -42,16 +55,14 @@ func (enc *Encoder) setError(err os.Error) {
 	if enc.err == nil { // remember the first.
 		enc.err = err
 	}
-	enc.state.b.Reset()
 }
 
-// Send the data item preceded by a unsigned count of its length.
-func (enc *Encoder) send() {
-	// Encode the length.
-	enc.countState.encodeUint(uint64(enc.state.b.Len()))
+// writeMessage sends the data item preceded by a unsigned count of its length.
+func (enc *Encoder) writeMessage(w io.Writer, b *bytes.Buffer) {
+	enc.countState.encodeUint(uint64(b.Len()))
 	// Build the buffer.
 	countLen := enc.countState.b.Len()
-	total := countLen + enc.state.b.Len()
+	total := countLen + b.Len()
 	if total > len(enc.buf) {
 		enc.buf = make([]byte, total+1000) // extra for growth
 	}
@@ -59,15 +70,15 @@ func (enc *Encoder) send() {
 	// TODO(r): avoid the extra copy here.
 	enc.countState.b.Read(enc.buf[0:countLen])
 	// Now the data.
-	enc.state.b.Read(enc.buf[countLen:total])
+	b.Read(enc.buf[countLen:total])
 	// Write the data.
-	_, err := enc.w.Write(enc.buf[0:total])
+	_, err := w.Write(enc.buf[0:total])
 	if err != nil {
 		enc.setError(err)
 	}
 }
 
-func (enc *Encoder) sendType(origt reflect.Type) (sent bool) {
+func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Type) (sent bool) {
 	// Drill down to the base type.
 	rt, _ := indirect(origt)
 
@@ -112,10 +123,10 @@ func (enc *Encoder) sendType(origt reflect.Type) (sent bool) {
 	}
 	// Send the pair (-id, type)
 	// Id:
-	enc.state.encodeInt(-int64(info.id))
+	state.encodeInt(-int64(info.id))
 	// Type:
-	enc.encode(enc.state.b, reflect.NewValue(info.wire))
-	enc.send()
+	enc.encode(state.b, reflect.NewValue(info.wire))
+	enc.writeMessage(w, state.b)
 	if enc.err != nil {
 		return
 	}
@@ -128,10 +139,10 @@ func (enc *Encoder) sendType(origt reflect.Type) (sent bool) {
 	switch st := rt.(type) {
 	case *reflect.StructType:
 		for i := 0; i < st.NumField(); i++ {
-			enc.sendType(st.Field(i).Type)
+			enc.sendType(w, state, st.Field(i).Type)
 		}
 	case reflect.ArrayOrSliceType:
-		enc.sendType(st.Elem())
+		enc.sendType(w, state, st.Elem())
 	}
 	return true
 }
@@ -144,13 +155,13 @@ func (enc *Encoder) Encode(e interface{}) os.Error {
 
 // sendTypeId makes sure the remote side knows about this type.
 // It will send a descriptor if this is the first time the type has been
-// sent.  Regardless, it sends the id.
-func (enc *Encoder) sendTypeDescriptor(rt reflect.Type) {
+// sent.
+func (enc *Encoder) sendTypeDescriptor(w io.Writer, state *encoderState, rt reflect.Type) {
 	// Make sure the type is known to the other side.
 	// First, have we already sent this type?
 	if _, alreadySent := enc.sent[rt]; !alreadySent {
 		// No, so send it.
-		sent := enc.sendType(rt)
+		sent := enc.sendType(w, state, rt)
 		if enc.err != nil {
 			return
 		}
@@ -168,9 +179,12 @@ func (enc *Encoder) sendTypeDescriptor(rt reflect.Type) {
 			enc.sent[rt] = info.id
 		}
 	}
+}
 
+// sendTypeId sends the id, which must have already been defined.
+func (enc *Encoder) sendTypeId(state *encoderState, rt reflect.Type) {
 	// Identify the type of this top-level value.
-	enc.state.encodeInt(int64(enc.sent[rt]))
+	state.encodeInt(int64(enc.sent[rt]))
 }
 
 // EncodeValue transmits the data item represented by the reflection value,
@@ -181,26 +195,26 @@ func (enc *Encoder) EncodeValue(value reflect.Value) os.Error {
 	enc.mutex.Lock()
 	defer enc.mutex.Unlock()
 
+	// Remove any nested writers remaining due to previous errors.
+	enc.w = enc.w[0:1]
+
 	enc.err = nil
 	rt, _ := indirect(value.Type())
 
-	// Sanity check only: encoder should never come in with data present.
-	if enc.state.b.Len() > 0 || enc.countState.b.Len() > 0 {
-		enc.err = os.ErrorString("encoder: buffer not empty")
-		return enc.err
-	}
+	state := newEncoderState(enc, new(bytes.Buffer))
 
-	enc.sendTypeDescriptor(rt)
+	enc.sendTypeDescriptor(enc.writer(), state, rt)
+	enc.sendTypeId(state, rt)
 	if enc.err != nil {
 		return enc.err
 	}
 
 	// Encode the object.
-	err := enc.encode(enc.state.b, value)
+	err := enc.encode(state.b, value)
 	if err != nil {
 		enc.setError(err)
 	} else {
-		enc.send()
+		enc.writeMessage(enc.writer(), state.b)
 	}
 
 	return enc.err