gitee.com/quant1x/gox@v1.21.2/encoding/binary/struc/types.go (about)

     1  package struc
     2  
     3  import (
     4  	"fmt"
     5  	"reflect"
     6  )
     7  
     8  type Type int
     9  
    10  const (
    11  	Invalid Type = iota
    12  	Pad
    13  	Bool
    14  	Int
    15  	Int8
    16  	Uint8
    17  	Int16
    18  	Uint16
    19  	Int32
    20  	Uint32
    21  	Int64
    22  	Uint64
    23  	Float32
    24  	Float64
    25  	String
    26  	Struct
    27  	Ptr
    28  
    29  	SizeType
    30  	OffType
    31  	CustomType
    32  )
    33  
    34  func (t Type) Resolve(options *Options) Type {
    35  	switch t {
    36  	case OffType:
    37  		switch options.PtrSize {
    38  		case 8:
    39  			return Int8
    40  		case 16:
    41  			return Int16
    42  		case 32:
    43  			return Int32
    44  		case 64:
    45  			return Int64
    46  		default:
    47  			panic(fmt.Sprintf("unsupported ptr bits: %d", options.PtrSize))
    48  		}
    49  	case SizeType:
    50  		switch options.PtrSize {
    51  		case 8:
    52  			return Uint8
    53  		case 16:
    54  			return Uint16
    55  		case 32:
    56  			return Uint32
    57  		case 64:
    58  			return Uint64
    59  		default:
    60  			panic(fmt.Sprintf("unsupported ptr bits: %d", options.PtrSize))
    61  		}
    62  	}
    63  	return t
    64  }
    65  
    66  func (t Type) String() string {
    67  	return typeNames[t]
    68  }
    69  
    70  func (t Type) Size() int {
    71  	switch t {
    72  	case SizeType, OffType:
    73  		panic("Size_t/Off_t types must be converted to another type using options.PtrSize")
    74  	case Pad, String, Int8, Uint8, Bool:
    75  		return 1
    76  	case Int16, Uint16:
    77  		return 2
    78  	case Int32, Uint32, Float32:
    79  		return 4
    80  	case Int64, Uint64, Float64:
    81  		return 8
    82  	default:
    83  		panic("Cannot resolve size of type:" + t.String())
    84  	}
    85  }
    86  
    87  var typeLookup = map[string]Type{
    88  	"pad":     Pad,
    89  	"bool":    Bool,
    90  	"byte":    Uint8,
    91  	"int8":    Int8,
    92  	"uint8":   Uint8,
    93  	"int16":   Int16,
    94  	"uint16":  Uint16,
    95  	"int32":   Int32,
    96  	"uint32":  Uint32,
    97  	"int64":   Int64,
    98  	"uint64":  Uint64,
    99  	"float32": Float32,
   100  	"float64": Float64,
   101  
   102  	"size_t": SizeType,
   103  	"off_t":  OffType,
   104  }
   105  
   106  var typeNames = map[Type]string{
   107  	CustomType: "Custom",
   108  }
   109  
   110  func init() {
   111  	for name, enum := range typeLookup {
   112  		typeNames[enum] = name
   113  	}
   114  }
   115  
   116  type Size_t uint64
   117  type Off_t int64
   118  
   119  var reflectTypeMap = map[reflect.Kind]Type{
   120  	reflect.Bool:    Bool,
   121  	reflect.Int8:    Int8,
   122  	reflect.Int16:   Int16,
   123  	reflect.Int:     Int32,
   124  	reflect.Int32:   Int32,
   125  	reflect.Int64:   Int64,
   126  	reflect.Uint8:   Uint8,
   127  	reflect.Uint16:  Uint16,
   128  	reflect.Uint:    Uint32,
   129  	reflect.Uint32:  Uint32,
   130  	reflect.Uint64:  Uint64,
   131  	reflect.Float32: Float32,
   132  	reflect.Float64: Float64,
   133  	reflect.String:  String,
   134  	reflect.Struct:  Struct,
   135  	reflect.Ptr:     Ptr,
   136  }