github.com/moontrade/unsafe@v0.9.1/memory/pointer.go (about)

     1  package memory
     2  
     3  import (
     4  	"github.com/moontrade/unsafe/memory/hash"
     5  	"unsafe"
     6  )
     7  
     8  // PtrSize is the size of a pointer in bytes - unsafe.Sizeof(uintptr(0)) but as an ideal constant.
     9  // It is also the size of the machine's native word size (that is, 4 on 32-bit systems, 8 on 64-bit).
    10  const PtrSize = 4 << (^uintptr(0) >> 63)
    11  
    12  type Bytes struct {
    13  	Pointer
    14  	Size uintptr
    15  }
    16  
    17  // Pointer is a wrapper around a raw pointer that is not unsafe.Pointer
    18  // so Go won't confuse it for a potential GC managed pointer.
    19  type Pointer uintptr
    20  
    21  func (p Pointer) Size() int {
    22  	return int(Sizeof(p))
    23  }
    24  
    25  func PointerOfString(s string) Pointer {
    26  	h := *(*_string)(unsafe.Pointer(&s))
    27  	return Pointer(h.ptr)
    28  }
    29  
    30  //goland:noinspection ALL
    31  func (p Pointer) Unsafe() unsafe.Pointer {
    32  	return unsafe.Pointer(p)
    33  }
    34  
    35  // Add is Pointer arithmetic.
    36  func (p Pointer) Add(offset int) Pointer {
    37  	return Pointer(uintptr(int(p) + offset))
    38  }
    39  
    40  // Free deallocates memory pointed by Pointer
    41  func (p *Pointer) Free() {
    42  	if p == nil || *p == 0 {
    43  		return
    44  	}
    45  	Free(*p)
    46  	*p = 0
    47  }
    48  
    49  // Sizeof returns the size of the allocation provided by the platform allocator.
    50  func (p Pointer) SizeOf() uintptr {
    51  	return Sizeof(p)
    52  }
    53  
    54  // Clone the memory starting at offset for size number of bytes and return the new Pointer.
    55  func (p Pointer) Clone(offset, size int) Pointer {
    56  	clone := Alloc(uintptr(size))
    57  	p.Copy(offset, size, clone)
    58  	return clone
    59  }
    60  
    61  // Zero zeroes out the entire allocation.
    62  func (p Pointer) Zero(size uintptr) {
    63  	Zero(p.Unsafe(), size)
    64  }
    65  
    66  // Move does a memmove
    67  
    68  func (p Pointer) Move(offset, size int, to Pointer) {
    69  	Move(to.Unsafe(), unsafe.Add(p.Unsafe(), offset), uintptr(size))
    70  }
    71  
    72  // Copy does a memcpy
    73  
    74  func (p Pointer) Copy(offset, size int, to Pointer) {
    75  	Copy(to.Unsafe(), unsafe.Add(p.Unsafe(), offset), uintptr(size))
    76  }
    77  
    78  // Equals does a memequal
    79  
    80  func (p Pointer) Equals(offset, size int, to Pointer) bool {
    81  	return Equals(to.Unsafe(), unsafe.Add(p.Unsafe(), offset), uintptr(size))
    82  }
    83  
    84  // Compare does a memcmp
    85  
    86  func (p Pointer) Compare(offset, size int, to Pointer) int {
    87  	return Compare(to.Unsafe(), unsafe.Add(p.Unsafe(), offset), uintptr(size))
    88  }
    89  
    90  ///////////////////////////////////////////////////////////////////////////////////////////////
    91  // Byte
    92  ///////////////////////////////////////////////////////////////////////////////////////////////
    93  
    94  func (p Pointer) Int8(offset int) int8 {
    95  	return *(*int8)(unsafe.Add(p.Unsafe(), offset))
    96  }
    97  
    98  func (p Pointer) Uint8(offset int) uint8 {
    99  	return *(*uint8)(unsafe.Add(p.Unsafe(), offset))
   100  }
   101  
   102  func (p Pointer) Byte(offset int) byte {
   103  	return *(*byte)(unsafe.Add(p.Unsafe(), offset))
   104  }
   105  
   106  ///////////////////////////////////////////////////////////////////////////////////////////////
   107  // Put Byte
   108  ///////////////////////////////////////////////////////////////////////////////////////////////
   109  
   110  func (p Pointer) SetInt8(offset int, v int8) {
   111  	*(*int8)(unsafe.Add(p.Unsafe(), offset)) = v
   112  }
   113  
   114  func (p Pointer) SetUint8(offset int, v uint8) {
   115  	*(*uint8)(unsafe.Add(p.Unsafe(), offset)) = v
   116  }
   117  
   118  func (p Pointer) SetByte(offset int, v byte) {
   119  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = v
   120  }
   121  
   122  ///////////////////////////////////////////////////////////////////////////////////////////////
   123  // Int16 Native Endian
   124  ///////////////////////////////////////////////////////////////////////////////////////////////
   125  
   126  func (p Pointer) Int16(offset int) int16 {
   127  	return *(*int16)(unsafe.Add(p.Unsafe(), offset))
   128  }
   129  
   130  func (p Pointer) SetInt16(offset int, v int16) {
   131  	*(*int16)(unsafe.Add(p.Unsafe(), offset)) = v
   132  }
   133  
   134  ///////////////////////////////////////////////////////////////////////////////////////////////
   135  // Uint16 Native Endian
   136  ///////////////////////////////////////////////////////////////////////////////////////////////
   137  
   138  func (p Pointer) Uint16(offset int) uint16 {
   139  	return *(*uint16)(unsafe.Add(p.Unsafe(), offset))
   140  }
   141  
   142  func (p Pointer) SetUint16(offset int, v uint16) {
   143  	*(*uint16)(unsafe.Add(p.Unsafe(), offset)) = v
   144  }
   145  
   146  ///////////////////////////////////////////////////////////////////////////////////////////////
   147  // Int32 Native Endian
   148  ///////////////////////////////////////////////////////////////////////////////////////////////
   149  
   150  func (p Pointer) Int32(offset int) int32 {
   151  	return *(*int32)(unsafe.Add(p.Unsafe(), offset))
   152  }
   153  func (p Pointer) Int32Alt(offset uintptr) int32 {
   154  	return *(*int32)(unsafe.Add(p.Unsafe(), offset))
   155  }
   156  
   157  func (p Pointer) SetInt32(offset int, v int32) {
   158  	*(*int32)(unsafe.Add(p.Unsafe(), offset)) = v
   159  }
   160  
   161  ///////////////////////////////////////////////////////////////////////////////////////////////
   162  // Uint32 Native Endian
   163  ///////////////////////////////////////////////////////////////////////////////////////////////
   164  
   165  func (p Pointer) Uint32(offset int) uint32 {
   166  	return *(*uint32)(unsafe.Add(p.Unsafe(), offset))
   167  }
   168  
   169  func (p Pointer) SetUint32(offset int, v uint32) {
   170  	*(*uint32)(unsafe.Add(p.Unsafe(), offset)) = v
   171  }
   172  
   173  ///////////////////////////////////////////////////////////////////////////////////////////////
   174  // Int64 Native Endian
   175  ///////////////////////////////////////////////////////////////////////////////////////////////
   176  
   177  func (p Pointer) Int64(offset int) int64 {
   178  	return *(*int64)(unsafe.Add(p.Unsafe(), offset))
   179  }
   180  
   181  func (p Pointer) SetInt64(offset int, v int64) {
   182  	*(*int64)(unsafe.Add(p.Unsafe(), offset)) = v
   183  }
   184  
   185  ///////////////////////////////////////////////////////////////////////////////////////////////
   186  // Uint64 Native Endian
   187  ///////////////////////////////////////////////////////////////////////////////////////////////
   188  
   189  func (p Pointer) Uint64(offset int) uint64 {
   190  	return *(*uint64)(unsafe.Add(p.Unsafe(), offset))
   191  }
   192  
   193  func (p Pointer) SetUint64(offset int, v uint64) {
   194  	*(*uint64)(unsafe.Add(p.Unsafe(), offset)) = v
   195  }
   196  
   197  ///////////////////////////////////////////////////////////////////////////////////////////////
   198  // Float32 Native Endian
   199  ///////////////////////////////////////////////////////////////////////////////////////////////
   200  
   201  func (p Pointer) Float32(offset int) float32 {
   202  	return *(*float32)(unsafe.Add(p.Unsafe(), offset))
   203  }
   204  
   205  func (p Pointer) SetFloat32(offset int, v float32) {
   206  	*(*float32)(unsafe.Add(p.Unsafe(), offset)) = v
   207  }
   208  
   209  ///////////////////////////////////////////////////////////////////////////////////////////////
   210  // Float64 Native Endian
   211  ///////////////////////////////////////////////////////////////////////////////////////////////
   212  
   213  func (p Pointer) Float64(offset int) float64 {
   214  	return *(*float64)(unsafe.Add(p.Unsafe(), offset))
   215  }
   216  
   217  func (p Pointer) SetFloat64(offset int, v float64) {
   218  	*(*float64)(unsafe.Add(p.Unsafe(), offset)) = v
   219  }
   220  
   221  ///////////////////////////////////////////////////////////////////////////////////////////////
   222  // int
   223  ///////////////////////////////////////////////////////////////////////////////////////////////
   224  
   225  func (p Pointer) Int(offset int) int {
   226  	return *(*int)(unsafe.Add(p.Unsafe(), offset))
   227  }
   228  
   229  func (p Pointer) SetInt(offset int, v int) {
   230  	*(*int)(unsafe.Add(p.Unsafe(), offset)) = v
   231  }
   232  
   233  ///////////////////////////////////////////////////////////////////////////////////////////////
   234  // uint
   235  ///////////////////////////////////////////////////////////////////////////////////////////////
   236  
   237  func (p Pointer) Uint(offset int) uint {
   238  	return *(*uint)(unsafe.Add(p.Unsafe(), offset))
   239  }
   240  
   241  func (p Pointer) SetUint(offset int, v uint) {
   242  	*(*uint)(unsafe.Add(p.Unsafe(), offset)) = v
   243  }
   244  
   245  ///////////////////////////////////////////////////////////////////////////////////////////////
   246  // uintptr
   247  ///////////////////////////////////////////////////////////////////////////////////////////////
   248  
   249  func (p Pointer) Uintptr(offset int) uintptr {
   250  	return *(*uintptr)(unsafe.Add(p.Unsafe(), offset))
   251  }
   252  
   253  func (p Pointer) SetUintptr(offset int, v uintptr) {
   254  	*(*uintptr)(unsafe.Add(p.Unsafe(), offset)) = v
   255  }
   256  
   257  ///////////////////////////////////////////////////////////////////////////////////////////////
   258  // Pointer
   259  ///////////////////////////////////////////////////////////////////////////////////////////////
   260  
   261  func (p Pointer) Pointer(offset int) Pointer {
   262  	return *(*Pointer)(unsafe.Add(p.Unsafe(), offset))
   263  }
   264  
   265  func (p Pointer) SetPointer(offset int, v Pointer) {
   266  	*(*Pointer)(unsafe.Add(p.Unsafe(), offset)) = v
   267  }
   268  
   269  ///////////////////////////////////////////////////////////////////////////////////////////////
   270  // String
   271  ///////////////////////////////////////////////////////////////////////////////////////////////
   272  
   273  type _string struct {
   274  	ptr uintptr
   275  	len int
   276  }
   277  
   278  func (p Pointer) String(offset, size int) string {
   279  	return *(*string)(unsafe.Pointer(&_string{
   280  		ptr: uintptr(int(p) + offset),
   281  		len: size,
   282  	}))
   283  }
   284  
   285  func (p Pointer) SetString(offset int, value string) {
   286  	dst := *(*[]byte)(unsafe.Pointer(&_bytes{
   287  		Data: uintptr(int(p) + offset),
   288  		Len:  len(value),
   289  		Cap:  len(value),
   290  	}))
   291  	copy(dst, value)
   292  }
   293  
   294  func (p Pointer) SetBytes(offset int, value []byte) {
   295  	dst := *(*[]byte)(unsafe.Pointer(&_bytes{
   296  		Data: uintptr(int(p) + offset),
   297  		Len:  len(value),
   298  		Cap:  len(value),
   299  	}))
   300  	copy(dst, value)
   301  }
   302  
   303  ///////////////////////////////////////////////////////////////////////////////////////////////
   304  // Byte Slice
   305  ///////////////////////////////////////////////////////////////////////////////////////////////
   306  
   307  type _bytes struct {
   308  	Data uintptr
   309  	Len  int
   310  	Cap  int
   311  }
   312  
   313  func (p Pointer) Bytes(offset, length, capacity int) []byte {
   314  	return *(*[]byte)(unsafe.Pointer(&_bytes{
   315  		Data: uintptr(int(p) + offset),
   316  		Len:  length,
   317  		Cap:  capacity,
   318  	}))
   319  }
   320  
   321  ///////////////////////////////////////////////////////////////////////////////////////////////
   322  // Int24 Little Endian
   323  ///////////////////////////////////////////////////////////////////////////////////////////////
   324  
   325  func (p Pointer) Int24LE(offset int) int32 {
   326  	return int32(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   327  		int32(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   328  		int32(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16
   329  }
   330  
   331  func (p Pointer) SetInt24LE(offset int, v int32) {
   332  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   333  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   334  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   335  }
   336  
   337  ///////////////////////////////////////////////////////////////////////////////////////////////
   338  // Int24 Big Endian
   339  ///////////////////////////////////////////////////////////////////////////////////////////////
   340  
   341  func (p Pointer) Int24BE(offset int) int32 {
   342  	return int32(*(*byte)(unsafe.Add(p.Unsafe(), offset+2))) |
   343  		int32(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   344  		int32(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<16
   345  }
   346  
   347  func (p Pointer) SetInt24BE(offset int, v int32) {
   348  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 16)
   349  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   350  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v)
   351  }
   352  
   353  ///////////////////////////////////////////////////////////////////////////////////////////////
   354  // Uint24 Little Endian
   355  ///////////////////////////////////////////////////////////////////////////////////////////////
   356  
   357  func (p Pointer) Uint24LE(offset int) uint32 {
   358  	return uint32(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   359  		uint32(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   360  		uint32(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16
   361  }
   362  
   363  func (p Pointer) SetUint24LE(offset int, v uint32) {
   364  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   365  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   366  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   367  }
   368  
   369  ///////////////////////////////////////////////////////////////////////////////////////////////
   370  // Uint24 Big Endian
   371  ///////////////////////////////////////////////////////////////////////////////////////////////
   372  
   373  func (p Pointer) Uint24BE(offset int) uint32 {
   374  	return uint32(*(*byte)(unsafe.Add(p.Unsafe(), offset+2))) |
   375  		uint32(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   376  		uint32(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<16
   377  }
   378  
   379  func (p Pointer) SetUint24BE(offset int, v uint32) {
   380  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 16)
   381  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   382  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v)
   383  }
   384  
   385  ///////////////////////////////////////////////////////////////////////////////////////////////
   386  // Int40 Little Endian
   387  ///////////////////////////////////////////////////////////////////////////////////////////////
   388  
   389  func (p Pointer) Int40LE(offset int) int64 {
   390  	return int64(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   391  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   392  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   393  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   394  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<32
   395  }
   396  
   397  func (p Pointer) SetInt40LE(offset int, v int64) {
   398  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   399  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   400  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   401  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   402  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 32)
   403  }
   404  
   405  ///////////////////////////////////////////////////////////////////////////////////////////////
   406  // Int40 Big Endian
   407  ///////////////////////////////////////////////////////////////////////////////////////////////
   408  
   409  func (p Pointer) Int40BE(offset int) int64 {
   410  	return int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4))) |
   411  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<8 |
   412  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   413  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<24 |
   414  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<32
   415  }
   416  
   417  func (p Pointer) SetInt40BE(offset int, v int64) {
   418  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 32)
   419  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 24)
   420  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   421  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 8)
   422  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v)
   423  }
   424  
   425  ///////////////////////////////////////////////////////////////////////////////////////////////
   426  // Uint40 Little Endian
   427  ///////////////////////////////////////////////////////////////////////////////////////////////
   428  
   429  func (p Pointer) Uint40LE(offset int) uint64 {
   430  	return uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   431  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   432  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   433  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   434  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<32
   435  }
   436  
   437  func (p Pointer) SetUint40LE(offset int, v uint64) {
   438  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   439  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   440  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   441  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   442  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 32)
   443  }
   444  
   445  ///////////////////////////////////////////////////////////////////////////////////////////////
   446  // Uint40 Big Endian
   447  ///////////////////////////////////////////////////////////////////////////////////////////////
   448  
   449  func (p Pointer) Uint40BE(offset int) uint64 {
   450  	return uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4))) |
   451  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<8 |
   452  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   453  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<24 |
   454  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<32
   455  }
   456  
   457  func (p Pointer) SetUint40BE(offset int, v uint64) {
   458  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 32)
   459  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 24)
   460  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   461  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 8)
   462  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v)
   463  }
   464  
   465  ///////////////////////////////////////////////////////////////////////////////////////////////
   466  // Int48 Little Endian
   467  ///////////////////////////////////////////////////////////////////////////////////////////////
   468  
   469  func (p Pointer) Int48LE(offset int) int64 {
   470  	return int64(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   471  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   472  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   473  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   474  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<32 |
   475  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5)))<<40
   476  }
   477  
   478  func (p Pointer) SetInt48LE(offset int, v int64) {
   479  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   480  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   481  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   482  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   483  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 32)
   484  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v >> 40)
   485  }
   486  
   487  ///////////////////////////////////////////////////////////////////////////////////////////////
   488  // Int48 Big Endian
   489  ///////////////////////////////////////////////////////////////////////////////////////////////
   490  
   491  func (p Pointer) Int48BE(offset int) int64 {
   492  	return int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5))) |
   493  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<8 |
   494  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<16 |
   495  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<24 |
   496  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<32 |
   497  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<40
   498  }
   499  
   500  func (p Pointer) SetInt48BE(offset int, v int64) {
   501  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 40)
   502  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 32)
   503  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 24)
   504  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 16)
   505  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 8)
   506  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v)
   507  }
   508  
   509  ///////////////////////////////////////////////////////////////////////////////////////////////
   510  // Uint48 Little Endian
   511  ///////////////////////////////////////////////////////////////////////////////////////////////
   512  
   513  func (p Pointer) Uint48LE(offset int) uint64 {
   514  	return uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   515  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   516  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   517  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   518  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<32 |
   519  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5)))<<40
   520  }
   521  
   522  func (p Pointer) SetUint48LE(offset int, v uint64) {
   523  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   524  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   525  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   526  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   527  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 32)
   528  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v >> 40)
   529  }
   530  
   531  ///////////////////////////////////////////////////////////////////////////////////////////////
   532  // Uint48 Big Endian
   533  ///////////////////////////////////////////////////////////////////////////////////////////////
   534  
   535  func (p Pointer) Uint48BE(offset int) uint64 {
   536  	return uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5))) |
   537  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<8 |
   538  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<16 |
   539  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<24 |
   540  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<32 |
   541  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<40
   542  }
   543  
   544  func (p Pointer) SetUint48BE(offset int, v uint64) {
   545  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 40)
   546  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 32)
   547  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 24)
   548  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 16)
   549  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 8)
   550  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v)
   551  }
   552  
   553  ///////////////////////////////////////////////////////////////////////////////////////////////
   554  // Int56 Little Endian
   555  ///////////////////////////////////////////////////////////////////////////////////////////////
   556  
   557  func (p Pointer) Int56LE(offset int) int64 {
   558  	return int64(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   559  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   560  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   561  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   562  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<32 |
   563  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5)))<<40 |
   564  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+6)))<<48
   565  }
   566  
   567  func (p Pointer) SetInt56LE(offset int, v int64) {
   568  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   569  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   570  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   571  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   572  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 32)
   573  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v >> 40)
   574  	*(*byte)(unsafe.Add(p.Unsafe(), offset+6)) = byte(v >> 48)
   575  }
   576  
   577  ///////////////////////////////////////////////////////////////////////////////////////////////
   578  // Int56 Big Endian
   579  ///////////////////////////////////////////////////////////////////////////////////////////////
   580  
   581  func (p Pointer) Int56BE(offset int) int64 {
   582  	return int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+6))) |
   583  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5)))<<8 |
   584  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<16 |
   585  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   586  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<32 |
   587  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<40 |
   588  		int64(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<48
   589  }
   590  
   591  func (p Pointer) SetInt56BE(offset int, v int64) {
   592  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 48)
   593  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 40)
   594  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 32)
   595  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   596  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 16)
   597  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v >> 8)
   598  	*(*byte)(unsafe.Add(p.Unsafe(), offset+6)) = byte(v)
   599  }
   600  
   601  ///////////////////////////////////////////////////////////////////////////////////////////////
   602  // Uint56 Little Endian
   603  ///////////////////////////////////////////////////////////////////////////////////////////////
   604  
   605  func (p Pointer) Uint56LE(offset int) uint64 {
   606  	return uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset))) |
   607  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<8 |
   608  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<16 |
   609  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   610  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<32 |
   611  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5)))<<40 |
   612  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+6)))<<48
   613  }
   614  
   615  func (p Pointer) SetUint56LE(offset int, v uint64) {
   616  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v)
   617  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 8)
   618  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 16)
   619  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   620  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 32)
   621  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v >> 40)
   622  	*(*byte)(unsafe.Add(p.Unsafe(), offset+6)) = byte(v >> 48)
   623  }
   624  
   625  ///////////////////////////////////////////////////////////////////////////////////////////////
   626  // Uint56 Big Endian
   627  ///////////////////////////////////////////////////////////////////////////////////////////////
   628  
   629  func (p Pointer) Uint56BE(offset int) uint64 {
   630  	return uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+6))) |
   631  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+5)))<<8 |
   632  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+4)))<<16 |
   633  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+3)))<<24 |
   634  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+2)))<<32 |
   635  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset+1)))<<40 |
   636  		uint64(*(*byte)(unsafe.Add(p.Unsafe(), offset)))<<48
   637  }
   638  
   639  func (p Pointer) SetUint56BE(offset int, v uint64) {
   640  	*(*byte)(unsafe.Add(p.Unsafe(), offset)) = byte(v >> 48)
   641  	*(*byte)(unsafe.Add(p.Unsafe(), offset+1)) = byte(v >> 40)
   642  	*(*byte)(unsafe.Add(p.Unsafe(), offset+2)) = byte(v >> 32)
   643  	*(*byte)(unsafe.Add(p.Unsafe(), offset+3)) = byte(v >> 24)
   644  	*(*byte)(unsafe.Add(p.Unsafe(), offset+4)) = byte(v >> 16)
   645  	*(*byte)(unsafe.Add(p.Unsafe(), offset+5)) = byte(v >> 8)
   646  	*(*byte)(unsafe.Add(p.Unsafe(), offset+6)) = byte(v)
   647  }
   648  
   649  func (p Pointer) Hash64(length int) uint64 {
   650  	return hash.Hash(p.Unsafe(), uint64(length), hash.DefaultSeed)
   651  }
   652  
   653  func (p Pointer) Hash64At(offset, length int) uint64 {
   654  	return hash.Hash(p.Pointer(offset).Unsafe(), uint64(length), hash.DefaultSeed)
   655  }