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