Imported Upstream version 1.1~hg20130304upstream/1.1_hg20130304

1 files changed, 70 insertions, 32 deletions

diff --git a/src/pkg/encoding/binary/binary.go b/src/pkg/encoding/binary/binary.go
index 712e490e6..edbac197d 100644
--- a/src/pkg/encoding/binary/binary.go
+++ b/src/pkg/encoding/binary/binary.go
@@ -125,6 +125,9 @@ func (bigEndian) GoString() string { return "binary.BigEndian" }
 // of fixed-size values.
 // Bytes read from r are decoded using the specified byte order
 // and written to successive fields of the data.
+// When reading into structs, the field data for fields with
+// blank (_) field names is skipped; i.e., blank field names
+// may be used for padding.
 func Read(r io.Reader, order ByteOrder, data interface{}) error {
 	// Fast path for basic types.
 	if n := intDestSize(data); n != 0 {
@@ -154,7 +157,7 @@ func Read(r io.Reader, order ByteOrder, data interface{}) error {
 		return nil
 	}
 
-	// Fallback to reflect-based.
+	// Fallback to reflect-based decoding.
 	var v reflect.Value
 	switch d := reflect.ValueOf(data); d.Kind() {
 	case reflect.Ptr:
@@ -164,9 +167,9 @@ func Read(r io.Reader, order ByteOrder, data interface{}) error {
 	default:
 		return errors.New("binary.Read: invalid type " + d.Type().String())
 	}
-	size := dataSize(v)
-	if size < 0 {
-		return errors.New("binary.Read: invalid type " + v.Type().String())
+	size, err := dataSize(v)
+	if err != nil {
+		return errors.New("binary.Read: " + err.Error())
 	}
 	d := &decoder{order: order, buf: make([]byte, size)}
 	if _, err := io.ReadFull(r, d.buf); err != nil {
@@ -181,6 +184,8 @@ func Read(r io.Reader, order ByteOrder, data interface{}) error {
 // values, or a pointer to such data.
 // Bytes written to w are encoded using the specified byte order
 // and read from successive fields of the data.
+// When writing structs, zero values are written for fields
+// with blank (_) field names.
 func Write(w io.Writer, order ByteOrder, data interface{}) error {
 	// Fast path for basic types.
 	var b [8]byte
@@ -239,76 +244,80 @@ func Write(w io.Writer, order ByteOrder, data interface{}) error {
 		_, err := w.Write(bs)
 		return err
 	}
+
+	// Fallback to reflect-based encoding.
 	v := reflect.Indirect(reflect.ValueOf(data))
-	size := dataSize(v)
-	if size < 0 {
-		return errors.New("binary.Write: invalid type " + v.Type().String())
+	size, err := dataSize(v)
+	if err != nil {
+		return errors.New("binary.Write: " + err.Error())
 	}
 	buf := make([]byte, size)
 	e := &encoder{order: order, buf: buf}
 	e.value(v)
-	_, err := w.Write(buf)
+	_, err = w.Write(buf)
 	return err
 }
 
 // Size returns how many bytes Write would generate to encode the value v, which
 // must be a fixed-size value or a slice of fixed-size values, or a pointer to such data.
 func Size(v interface{}) int {
-	return dataSize(reflect.Indirect(reflect.ValueOf(v)))
+	n, err := dataSize(reflect.Indirect(reflect.ValueOf(v)))
+	if err != nil {
+		return -1
+	}
+	return n
 }
 
 // dataSize returns the number of bytes the actual data represented by v occupies in memory.
 // For compound structures, it sums the sizes of the elements. Thus, for instance, for a slice
 // it returns the length of the slice times the element size and does not count the memory
 // occupied by the header.
-func dataSize(v reflect.Value) int {
+func dataSize(v reflect.Value) (int, error) {
 	if v.Kind() == reflect.Slice {
-		elem := sizeof(v.Type().Elem())
-		if elem < 0 {
-			return -1
+		elem, err := sizeof(v.Type().Elem())
+		if err != nil {
+			return 0, err
 		}
-		return v.Len() * elem
+		return v.Len() * elem, nil
 	}
 	return sizeof(v.Type())
 }
 
-func sizeof(t reflect.Type) int {
+func sizeof(t reflect.Type) (int, error) {
 	switch t.Kind() {
 	case reflect.Array:
-		n := sizeof(t.Elem())
-		if n < 0 {
-			return -1
+		n, err := sizeof(t.Elem())
+		if err != nil {
+			return 0, err
 		}
-		return t.Len() * n
+		return t.Len() * n, nil
 
 	case reflect.Struct:
 		sum := 0
 		for i, n := 0, t.NumField(); i < n; i++ {
-			s := sizeof(t.Field(i).Type)
-			if s < 0 {
-				return -1
+			s, err := sizeof(t.Field(i).Type)
+			if err != nil {
+				return 0, err
 			}
 			sum += s
 		}
-		return sum
+		return sum, nil
 
 	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
 		reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
 		reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
-		return int(t.Size())
+		return int(t.Size()), nil
 	}
-	return -1
+	return 0, errors.New("invalid type " + t.String())
 }
 
-type decoder struct {
+type coder struct {
 	order ByteOrder
 	buf   []byte
 }
 
-type encoder struct {
-	order ByteOrder
-	buf   []byte
-}
+type decoder coder
+type encoder coder
 
 func (d *decoder) uint8() uint8 {
 	x := d.buf[0]
@@ -379,9 +388,19 @@ func (d *decoder) value(v reflect.Value) {
 		}
 
 	case reflect.Struct:
+		t := v.Type()
 		l := v.NumField()
 		for i := 0; i < l; i++ {
-			d.value(v.Field(i))
+			// Note: Calling v.CanSet() below is an optimization.
+			// It would be sufficient to check the field name,
+			// but creating the StructField info for each field is
+			// costly (run "go test -bench=ReadStruct" and compare
+			// results when making changes to this code).
+			if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
+				d.value(v)
+			} else {
+				d.skip(v)
+			}
 		}
 
 	case reflect.Slice:
@@ -435,9 +454,15 @@ func (e *encoder) value(v reflect.Value) {
 		}
 
 	case reflect.Struct:
+		t := v.Type()
 		l := v.NumField()
 		for i := 0; i < l; i++ {
-			e.value(v.Field(i))
+			// see comment for corresponding code in decoder.value()
+			if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
+				e.value(v)
+			} else {
+				e.skip(v)
+			}
 		}
 
 	case reflect.Slice:
@@ -492,6 +517,19 @@ func (e *encoder) value(v reflect.Value) {
 	}
 }
 
+func (d *decoder) skip(v reflect.Value) {
+	n, _ := dataSize(v)
+	d.buf = d.buf[n:]
+}
+
+func (e *encoder) skip(v reflect.Value) {
+	n, _ := dataSize(v)
+	for i := range e.buf[0:n] {
+		e.buf[i] = 0
+	}
+	e.buf = e.buf[n:]
+}
+
 // intDestSize returns the size of the integer that ptrType points to,
 // or 0 if the type is not supported.
 func intDestSize(ptrType interface{}) int {