← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/encoding/binary/binary.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/encoding/binary/binary.go
125
125
// of fixed-size values.
126
126
// Bytes read from r are decoded using the specified byte order
127
127
// and written to successive fields of the data.
 
128
// When reading into structs, the field data for fields with
 
129
// blank (_) field names is skipped; i.e., blank field names
 
130
// may be used for padding.
128
131
func Read(r io.Reader, order ByteOrder, data interface{}) error {
129
132
        // Fast path for basic types.
130
133
        if n := intDestSize(data); n != 0 {
154
157
                return nil
155
158
        }
156
159
 
157
 
        // Fallback to reflect-based.
 
160
        // Fallback to reflect-based decoding.
158
161
        var v reflect.Value
159
162
        switch d := reflect.ValueOf(data); d.Kind() {
160
163
        case reflect.Ptr:
164
167
        default:
165
168
                return errors.New("binary.Read: invalid type " + d.Type().String())
166
169
        }
167
 
        size := dataSize(v)
168
 
        if size < 0 {
169
 
                return errors.New("binary.Read: invalid type " + v.Type().String())
 
170
        size, err := dataSize(v)
 
171
        if err != nil {
 
172
                return errors.New("binary.Read: " + err.Error())
170
173
        }
171
174
        d := &decoder{order: order, buf: make([]byte, size)}
172
175
        if _, err := io.ReadFull(r, d.buf); err != nil {
181
184
// values, or a pointer to such data.
182
185
// Bytes written to w are encoded using the specified byte order
183
186
// and read from successive fields of the data.
 
187
// When writing structs, zero values are written for fields
 
188
// with blank (_) field names.
184
189
func Write(w io.Writer, order ByteOrder, data interface{}) error {
185
190
        // Fast path for basic types.
186
191
        var b [8]byte
239
244
                _, err := w.Write(bs)
240
245
                return err
241
246
        }
 
247
 
 
248
        // Fallback to reflect-based encoding.
242
249
        v := reflect.Indirect(reflect.ValueOf(data))
243
 
        size := dataSize(v)
244
 
        if size < 0 {
245
 
                return errors.New("binary.Write: invalid type " + v.Type().String())
 
250
        size, err := dataSize(v)
 
251
        if err != nil {
 
252
                return errors.New("binary.Write: " + err.Error())
246
253
        }
247
254
        buf := make([]byte, size)
248
255
        e := &encoder{order: order, buf: buf}
249
256
        e.value(v)
250
 
        _, err := w.Write(buf)
 
257
        _, err = w.Write(buf)
251
258
        return err
252
259
}
253
260
 
254
261
// Size returns how many bytes Write would generate to encode the value v, which
255
262
// must be a fixed-size value or a slice of fixed-size values, or a pointer to such data.
256
263
func Size(v interface{}) int {
257
 
        return dataSize(reflect.Indirect(reflect.ValueOf(v)))
 
264
        n, err := dataSize(reflect.Indirect(reflect.ValueOf(v)))
 
265
        if err != nil {
 
266
                return -1
 
267
        }
 
268
        return n
258
269
}
259
270
 
260
271
// dataSize returns the number of bytes the actual data represented by v occupies in memory.
261
272
// For compound structures, it sums the sizes of the elements. Thus, for instance, for a slice
262
273
// it returns the length of the slice times the element size and does not count the memory
263
274
// occupied by the header.
264
 
func dataSize(v reflect.Value) int {
 
275
func dataSize(v reflect.Value) (int, error) {
265
276
        if v.Kind() == reflect.Slice {
266
 
                elem := sizeof(v.Type().Elem())
267
 
                if elem < 0 {
268
 
                        return -1
 
277
                elem, err := sizeof(v.Type().Elem())
 
278
                if err != nil {
 
279
                        return 0, err
269
280
                }
270
 
                return v.Len() * elem
 
281
                return v.Len() * elem, nil
271
282
        }
272
283
        return sizeof(v.Type())
273
284
}
274
285
 
275
 
func sizeof(t reflect.Type) int {
 
286
func sizeof(t reflect.Type) (int, error) {
276
287
        switch t.Kind() {
277
288
        case reflect.Array:
278
 
                n := sizeof(t.Elem())
279
 
                if n < 0 {
280
 
                        return -1
 
289
                n, err := sizeof(t.Elem())
 
290
                if err != nil {
 
291
                        return 0, err
281
292
                }
282
 
                return t.Len() * n
 
293
                return t.Len() * n, nil
283
294
 
284
295
        case reflect.Struct:
285
296
                sum := 0
286
297
                for i, n := 0, t.NumField(); i < n; i++ {
287
 
                        s := sizeof(t.Field(i).Type)
288
 
                        if s < 0 {
289
 
                                return -1
 
298
                        s, err := sizeof(t.Field(i).Type)
 
299
                        if err != nil {
 
300
                                return 0, err
290
301
                        }
291
302
                        sum += s
292
303
                }
293
 
                return sum
 
304
                return sum, nil
294
305
 
295
306
        case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
296
307
                reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
297
308
                reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
298
 
                return int(t.Size())
 
309
                return int(t.Size()), nil
299
310
        }
300
 
        return -1
301
 
}
302
 
 
303
 
type decoder struct {
304
 
        order ByteOrder
305
 
        buf   []byte
306
 
}
307
 
 
308
 
type encoder struct {
309
 
        order ByteOrder
310
 
        buf   []byte
311
 
}
 
311
        return 0, errors.New("invalid type " + t.String())
 
312
}
 
313
 
 
314
type coder struct {
 
315
        order ByteOrder
 
316
        buf   []byte
 
317
}
 
318
 
 
319
type decoder coder
 
320
type encoder coder
312
321
 
313
322
func (d *decoder) uint8() uint8 {
314
323
        x := d.buf[0]
379
388
                }
380
389
 
381
390
        case reflect.Struct:
 
391
                t := v.Type()
382
392
                l := v.NumField()
383
393
                for i := 0; i < l; i++ {
384
 
                        d.value(v.Field(i))
 
394
                        // Note: Calling v.CanSet() below is an optimization.
 
395
                        // It would be sufficient to check the field name,
 
396
                        // but creating the StructField info for each field is
 
397
                        // costly (run "go test -bench=ReadStruct" and compare
 
398
                        // results when making changes to this code).
 
399
                        if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
 
400
                                d.value(v)
 
401
                        } else {
 
402
                                d.skip(v)
 
403
                        }
385
404
                }
386
405
 
387
406
        case reflect.Slice:
435
454
                }
436
455
 
437
456
        case reflect.Struct:
 
457
                t := v.Type()
438
458
                l := v.NumField()
439
459
                for i := 0; i < l; i++ {
440
 
                        e.value(v.Field(i))
 
460
                        // see comment for corresponding code in decoder.value()
 
461
                        if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
 
462
                                e.value(v)
 
463
                        } else {
 
464
                                e.skip(v)
 
465
                        }
441
466
                }
442
467
 
443
468
        case reflect.Slice:
492
517
        }
493
518
}
494
519
 
 
520
func (d *decoder) skip(v reflect.Value) {
 
521
        n, _ := dataSize(v)
 
522
        d.buf = d.buf[n:]
 
523
}
 
524
 
 
525
func (e *encoder) skip(v reflect.Value) {
 
526
        n, _ := dataSize(v)
 
527
        for i := range e.buf[0:n] {
 
528
                e.buf[i] = 0
 
529
        }
 
530
        e.buf = e.buf[n:]
 
531
}
 
532
 
495
533
// intDestSize returns the size of the integer that ptrType points to,
496
534
// or 0 if the type is not supported.
497
535
func intDestSize(ptrType interface{}) int {