1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 package binary
23
24 import (
25 "errors"
26 "io"
27 "math"
28 "reflect"
29 )
30
31
32
33 type ByteOrder interface {
34 Uint16([]byte) uint16
35 Uint32([]byte) uint32
36 Uint64([]byte) uint64
37 PutUint16([]byte, uint16)
38 PutUint32([]byte, uint32)
39 PutUint64([]byte, uint64)
40 String() string
41 }
42
43
44 var LittleEndian littleEndian
45
46
47 var BigEndian bigEndian
48
49 type littleEndian struct{}
50
51 func (littleEndian) Uint16(b []byte) uint16 {
52 _ = b[1]
53 return uint16(b[0]) | uint16(b[1])<<8
54 }
55
56 func (littleEndian) PutUint16(b []byte, v uint16) {
57 _ = b[1]
58 b[0] = byte(v)
59 b[1] = byte(v >> 8)
60 }
61
62 func (littleEndian) Uint32(b []byte) uint32 {
63 _ = b[3]
64 return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
65 }
66
67 func (littleEndian) PutUint32(b []byte, v uint32) {
68 _ = b[3]
69 b[0] = byte(v)
70 b[1] = byte(v >> 8)
71 b[2] = byte(v >> 16)
72 b[3] = byte(v >> 24)
73 }
74
75 func (littleEndian) Uint64(b []byte) uint64 {
76 _ = b[7]
77 return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
78 uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
79 }
80
81 func (littleEndian) PutUint64(b []byte, v uint64) {
82 _ = b[7]
83 b[0] = byte(v)
84 b[1] = byte(v >> 8)
85 b[2] = byte(v >> 16)
86 b[3] = byte(v >> 24)
87 b[4] = byte(v >> 32)
88 b[5] = byte(v >> 40)
89 b[6] = byte(v >> 48)
90 b[7] = byte(v >> 56)
91 }
92
93 func (littleEndian) String() string { return "LittleEndian" }
94
95 func (littleEndian) GoString() string { return "binary.LittleEndian" }
96
97 type bigEndian struct{}
98
99 func (bigEndian) Uint16(b []byte) uint16 {
100 _ = b[1]
101 return uint16(b[1]) | uint16(b[0])<<8
102 }
103
104 func (bigEndian) PutUint16(b []byte, v uint16) {
105 _ = b[1]
106 b[0] = byte(v >> 8)
107 b[1] = byte(v)
108 }
109
110 func (bigEndian) Uint32(b []byte) uint32 {
111 _ = b[3]
112 return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
113 }
114
115 func (bigEndian) PutUint32(b []byte, v uint32) {
116 _ = b[3]
117 b[0] = byte(v >> 24)
118 b[1] = byte(v >> 16)
119 b[2] = byte(v >> 8)
120 b[3] = byte(v)
121 }
122
123 func (bigEndian) Uint64(b []byte) uint64 {
124 _ = b[7]
125 return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |
126 uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56
127 }
128
129 func (bigEndian) PutUint64(b []byte, v uint64) {
130 _ = b[7]
131 b[0] = byte(v >> 56)
132 b[1] = byte(v >> 48)
133 b[2] = byte(v >> 40)
134 b[3] = byte(v >> 32)
135 b[4] = byte(v >> 24)
136 b[5] = byte(v >> 16)
137 b[6] = byte(v >> 8)
138 b[7] = byte(v)
139 }
140
141 func (bigEndian) String() string { return "BigEndian" }
142
143 func (bigEndian) GoString() string { return "binary.BigEndian" }
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161 func Read(r io.Reader, order ByteOrder, data interface{}) error {
162
163 if n := intDataSize(data); n != 0 {
164 var b [8]byte
165 var bs []byte
166 if n > len(b) {
167 bs = make([]byte, n)
168 } else {
169 bs = b[:n]
170 }
171 if _, err := io.ReadFull(r, bs); err != nil {
172 return err
173 }
174 switch data := data.(type) {
175 case *bool:
176 *data = b[0] != 0
177 case *int8:
178 *data = int8(b[0])
179 case *uint8:
180 *data = b[0]
181 case *int16:
182 *data = int16(order.Uint16(bs))
183 case *uint16:
184 *data = order.Uint16(bs)
185 case *int32:
186 *data = int32(order.Uint32(bs))
187 case *uint32:
188 *data = order.Uint32(bs)
189 case *int64:
190 *data = int64(order.Uint64(bs))
191 case *uint64:
192 *data = order.Uint64(bs)
193 case []bool:
194 for i, x := range bs {
195 data[i] = x != 0
196 }
197 case []int8:
198 for i, x := range bs {
199 data[i] = int8(x)
200 }
201 case []uint8:
202 copy(data, bs)
203 case []int16:
204 for i := range data {
205 data[i] = int16(order.Uint16(bs[2*i:]))
206 }
207 case []uint16:
208 for i := range data {
209 data[i] = order.Uint16(bs[2*i:])
210 }
211 case []int32:
212 for i := range data {
213 data[i] = int32(order.Uint32(bs[4*i:]))
214 }
215 case []uint32:
216 for i := range data {
217 data[i] = order.Uint32(bs[4*i:])
218 }
219 case []int64:
220 for i := range data {
221 data[i] = int64(order.Uint64(bs[8*i:]))
222 }
223 case []uint64:
224 for i := range data {
225 data[i] = order.Uint64(bs[8*i:])
226 }
227 }
228 return nil
229 }
230
231
232 v := reflect.ValueOf(data)
233 size := -1
234 switch v.Kind() {
235 case reflect.Ptr:
236 v = v.Elem()
237 size = dataSize(v)
238 case reflect.Slice:
239 size = dataSize(v)
240 }
241 if size < 0 {
242 return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
243 }
244 d := &decoder{order: order, buf: make([]byte, size)}
245 if _, err := io.ReadFull(r, d.buf); err != nil {
246 return err
247 }
248 d.value(v)
249 return nil
250 }
251
252
253
254
255
256
257
258
259
260 func Write(w io.Writer, order ByteOrder, data interface{}) error {
261
262 if n := intDataSize(data); n != 0 {
263 var b [8]byte
264 var bs []byte
265 if n > len(b) {
266 bs = make([]byte, n)
267 } else {
268 bs = b[:n]
269 }
270 switch v := data.(type) {
271 case *bool:
272 if *v {
273 b[0] = 1
274 } else {
275 b[0] = 0
276 }
277 case bool:
278 if v {
279 b[0] = 1
280 } else {
281 b[0] = 0
282 }
283 case []bool:
284 for i, x := range v {
285 if x {
286 bs[i] = 1
287 } else {
288 bs[i] = 0
289 }
290 }
291 case *int8:
292 b[0] = byte(*v)
293 case int8:
294 b[0] = byte(v)
295 case []int8:
296 for i, x := range v {
297 bs[i] = byte(x)
298 }
299 case *uint8:
300 b[0] = *v
301 case uint8:
302 b[0] = v
303 case []uint8:
304 bs = v
305 case *int16:
306 order.PutUint16(bs, uint16(*v))
307 case int16:
308 order.PutUint16(bs, uint16(v))
309 case []int16:
310 for i, x := range v {
311 order.PutUint16(bs[2*i:], uint16(x))
312 }
313 case *uint16:
314 order.PutUint16(bs, *v)
315 case uint16:
316 order.PutUint16(bs, v)
317 case []uint16:
318 for i, x := range v {
319 order.PutUint16(bs[2*i:], x)
320 }
321 case *int32:
322 order.PutUint32(bs, uint32(*v))
323 case int32:
324 order.PutUint32(bs, uint32(v))
325 case []int32:
326 for i, x := range v {
327 order.PutUint32(bs[4*i:], uint32(x))
328 }
329 case *uint32:
330 order.PutUint32(bs, *v)
331 case uint32:
332 order.PutUint32(bs, v)
333 case []uint32:
334 for i, x := range v {
335 order.PutUint32(bs[4*i:], x)
336 }
337 case *int64:
338 order.PutUint64(bs, uint64(*v))
339 case int64:
340 order.PutUint64(bs, uint64(v))
341 case []int64:
342 for i, x := range v {
343 order.PutUint64(bs[8*i:], uint64(x))
344 }
345 case *uint64:
346 order.PutUint64(bs, *v)
347 case uint64:
348 order.PutUint64(bs, v)
349 case []uint64:
350 for i, x := range v {
351 order.PutUint64(bs[8*i:], x)
352 }
353 }
354 _, err := w.Write(bs)
355 return err
356 }
357
358
359 v := reflect.Indirect(reflect.ValueOf(data))
360 size := dataSize(v)
361 if size < 0 {
362 return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())
363 }
364 buf := make([]byte, size)
365 e := &encoder{order: order, buf: buf}
366 e.value(v)
367 _, err := w.Write(buf)
368 return err
369 }
370
371
372
373
374 func Size(v interface{}) int {
375 return dataSize(reflect.Indirect(reflect.ValueOf(v)))
376 }
377
378
379
380
381
382 func dataSize(v reflect.Value) int {
383 if v.Kind() == reflect.Slice {
384 if s := sizeof(v.Type().Elem()); s >= 0 {
385 return s * v.Len()
386 }
387 return -1
388 }
389 return sizeof(v.Type())
390 }
391
392
393 func sizeof(t reflect.Type) int {
394 switch t.Kind() {
395 case reflect.Array:
396 if s := sizeof(t.Elem()); s >= 0 {
397 return s * t.Len()
398 }
399
400 case reflect.Struct:
401 sum := 0
402 for i, n := 0, t.NumField(); i < n; i++ {
403 s := sizeof(t.Field(i).Type)
404 if s < 0 {
405 return -1
406 }
407 sum += s
408 }
409 return sum
410
411 case reflect.Bool,
412 reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
413 reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
414 reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128:
415 return int(t.Size())
416 }
417
418 return -1
419 }
420
421 type coder struct {
422 order ByteOrder
423 buf []byte
424 }
425
426 type decoder coder
427 type encoder coder
428
429 func (d *decoder) bool() bool {
430 x := d.buf[0]
431 d.buf = d.buf[1:]
432 return x != 0
433 }
434
435 func (e *encoder) bool(x bool) {
436 if x {
437 e.buf[0] = 1
438 } else {
439 e.buf[0] = 0
440 }
441 e.buf = e.buf[1:]
442 }
443
444 func (d *decoder) uint8() uint8 {
445 x := d.buf[0]
446 d.buf = d.buf[1:]
447 return x
448 }
449
450 func (e *encoder) uint8(x uint8) {
451 e.buf[0] = x
452 e.buf = e.buf[1:]
453 }
454
455 func (d *decoder) uint16() uint16 {
456 x := d.order.Uint16(d.buf[0:2])
457 d.buf = d.buf[2:]
458 return x
459 }
460
461 func (e *encoder) uint16(x uint16) {
462 e.order.PutUint16(e.buf[0:2], x)
463 e.buf = e.buf[2:]
464 }
465
466 func (d *decoder) uint32() uint32 {
467 x := d.order.Uint32(d.buf[0:4])
468 d.buf = d.buf[4:]
469 return x
470 }
471
472 func (e *encoder) uint32(x uint32) {
473 e.order.PutUint32(e.buf[0:4], x)
474 e.buf = e.buf[4:]
475 }
476
477 func (d *decoder) uint64() uint64 {
478 x := d.order.Uint64(d.buf[0:8])
479 d.buf = d.buf[8:]
480 return x
481 }
482
483 func (e *encoder) uint64(x uint64) {
484 e.order.PutUint64(e.buf[0:8], x)
485 e.buf = e.buf[8:]
486 }
487
488 func (d *decoder) int8() int8 { return int8(d.uint8()) }
489
490 func (e *encoder) int8(x int8) { e.uint8(uint8(x)) }
491
492 func (d *decoder) int16() int16 { return int16(d.uint16()) }
493
494 func (e *encoder) int16(x int16) { e.uint16(uint16(x)) }
495
496 func (d *decoder) int32() int32 { return int32(d.uint32()) }
497
498 func (e *encoder) int32(x int32) { e.uint32(uint32(x)) }
499
500 func (d *decoder) int64() int64 { return int64(d.uint64()) }
501
502 func (e *encoder) int64(x int64) { e.uint64(uint64(x)) }
503
504 func (d *decoder) value(v reflect.Value) {
505 switch v.Kind() {
506 case reflect.Array:
507 l := v.Len()
508 for i := 0; i < l; i++ {
509 d.value(v.Index(i))
510 }
511
512 case reflect.Struct:
513 t := v.Type()
514 l := v.NumField()
515 for i := 0; i < l; i++ {
516
517
518
519
520
521 if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
522 d.value(v)
523 } else {
524 d.skip(v)
525 }
526 }
527
528 case reflect.Slice:
529 l := v.Len()
530 for i := 0; i < l; i++ {
531 d.value(v.Index(i))
532 }
533
534 case reflect.Bool:
535 v.SetBool(d.bool())
536
537 case reflect.Int8:
538 v.SetInt(int64(d.int8()))
539 case reflect.Int16:
540 v.SetInt(int64(d.int16()))
541 case reflect.Int32:
542 v.SetInt(int64(d.int32()))
543 case reflect.Int64:
544 v.SetInt(d.int64())
545
546 case reflect.Uint8:
547 v.SetUint(uint64(d.uint8()))
548 case reflect.Uint16:
549 v.SetUint(uint64(d.uint16()))
550 case reflect.Uint32:
551 v.SetUint(uint64(d.uint32()))
552 case reflect.Uint64:
553 v.SetUint(d.uint64())
554
555 case reflect.Float32:
556 v.SetFloat(float64(math.Float32frombits(d.uint32())))
557 case reflect.Float64:
558 v.SetFloat(math.Float64frombits(d.uint64()))
559
560 case reflect.Complex64:
561 v.SetComplex(complex(
562 float64(math.Float32frombits(d.uint32())),
563 float64(math.Float32frombits(d.uint32())),
564 ))
565 case reflect.Complex128:
566 v.SetComplex(complex(
567 math.Float64frombits(d.uint64()),
568 math.Float64frombits(d.uint64()),
569 ))
570 }
571 }
572
573 func (e *encoder) value(v reflect.Value) {
574 switch v.Kind() {
575 case reflect.Array:
576 l := v.Len()
577 for i := 0; i < l; i++ {
578 e.value(v.Index(i))
579 }
580
581 case reflect.Struct:
582 t := v.Type()
583 l := v.NumField()
584 for i := 0; i < l; i++ {
585
586 if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" {
587 e.value(v)
588 } else {
589 e.skip(v)
590 }
591 }
592
593 case reflect.Slice:
594 l := v.Len()
595 for i := 0; i < l; i++ {
596 e.value(v.Index(i))
597 }
598
599 case reflect.Bool:
600 e.bool(v.Bool())
601
602 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
603 switch v.Type().Kind() {
604 case reflect.Int8:
605 e.int8(int8(v.Int()))
606 case reflect.Int16:
607 e.int16(int16(v.Int()))
608 case reflect.Int32:
609 e.int32(int32(v.Int()))
610 case reflect.Int64:
611 e.int64(v.Int())
612 }
613
614 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
615 switch v.Type().Kind() {
616 case reflect.Uint8:
617 e.uint8(uint8(v.Uint()))
618 case reflect.Uint16:
619 e.uint16(uint16(v.Uint()))
620 case reflect.Uint32:
621 e.uint32(uint32(v.Uint()))
622 case reflect.Uint64:
623 e.uint64(v.Uint())
624 }
625
626 case reflect.Float32, reflect.Float64:
627 switch v.Type().Kind() {
628 case reflect.Float32:
629 e.uint32(math.Float32bits(float32(v.Float())))
630 case reflect.Float64:
631 e.uint64(math.Float64bits(v.Float()))
632 }
633
634 case reflect.Complex64, reflect.Complex128:
635 switch v.Type().Kind() {
636 case reflect.Complex64:
637 x := v.Complex()
638 e.uint32(math.Float32bits(float32(real(x))))
639 e.uint32(math.Float32bits(float32(imag(x))))
640 case reflect.Complex128:
641 x := v.Complex()
642 e.uint64(math.Float64bits(real(x)))
643 e.uint64(math.Float64bits(imag(x)))
644 }
645 }
646 }
647
648 func (d *decoder) skip(v reflect.Value) {
649 d.buf = d.buf[dataSize(v):]
650 }
651
652 func (e *encoder) skip(v reflect.Value) {
653 n := dataSize(v)
654 for i := range e.buf[0:n] {
655 e.buf[i] = 0
656 }
657 e.buf = e.buf[n:]
658 }
659
660
661
662 func intDataSize(data interface{}) int {
663 switch data := data.(type) {
664 case bool, int8, uint8, *bool, *int8, *uint8:
665 return 1
666 case []int8:
667 return len(data)
668 case []uint8:
669 return len(data)
670 case int16, uint16, *int16, *uint16:
671 return 2
672 case []int16:
673 return 2 * len(data)
674 case []uint16:
675 return 2 * len(data)
676 case int32, uint32, *int32, *uint32:
677 return 4
678 case []int32:
679 return 4 * len(data)
680 case []uint32:
681 return 4 * len(data)
682 case int64, uint64, *int64, *uint64:
683 return 8
684 case []int64:
685 return 8 * len(data)
686 case []uint64:
687 return 8 * len(data)
688 }
689 return 0
690 }
691
View as plain text