github.com/moontrade/nogc@v0.1.7/pointer_be.go (about)

     1  //go:build arm64be || armbe || mips || mips64 || ppc || ppc64 || s390 || s390x || sparc || sparc64
     2  // +build arm64be armbe mips mips64 ppc ppc64 s390 s390x sparc sparc64
     3  
     4  package nogc
     5  
     6  import (
     7  	"math/bits"
     8  	"unsafe"
     9  )
    10  
    11  ///////////////////////////////////////////////////////////////////////////////////////////////
    12  // Int16 Big Endian
    13  ///////////////////////////////////////////////////////////////////////////////////////////////
    14  
    15  //goland:noinspection GoVetUnsafePointer
    16  func (p Pointer) Int16BE(offset int) int16 {
    17  	return *(*int16)(unsafe.Pointer(uintptr(int(p) + offset)))
    18  }
    19  
    20  //goland:noinspection GoVetUnsafePointer
    21  func (p Pointer) SetInt16BE(offset int, v int16) {
    22  	*(*int16)(unsafe.Pointer(uintptr(int(p) + offset))) = v
    23  }
    24  
    25  ///////////////////////////////////////////////////////////////////////////////////////////////
    26  // Int16 Little Endian
    27  ///////////////////////////////////////////////////////////////////////////////////////////////
    28  
    29  //goland:noinspection GoVetUnsafePointer
    30  func (p Pointer) Int16LE(offset int) int16 {
    31  	return int16(bits.ReverseBytes16(*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset)))))
    32  }
    33  
    34  //goland:noinspection GoVetUnsafePointer
    35  func (p Pointer) SetInt16LE(offset int, v int16) {
    36  	*(*int16)(unsafe.Pointer(uintptr(int(p) + offset))) = int16(bits.ReverseBytes16(uint16(v)))
    37  }
    38  
    39  ///////////////////////////////////////////////////////////////////////////////////////////////
    40  // Uint16 Big Endian
    41  ///////////////////////////////////////////////////////////////////////////////////////////////
    42  
    43  //goland:noinspection GoVetUnsafePointer
    44  func (p Pointer) Uint16BE(offset int) uint16 {
    45  	return *(*uint16)(unsafe.Pointer(uintptr(int(p) + offset)))
    46  }
    47  
    48  //goland:noinspection GoVetUnsafePointer
    49  func (p Pointer) SetUint16BE(offset int, v uint16) {
    50  	*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset))) = v
    51  }
    52  
    53  ///////////////////////////////////////////////////////////////////////////////////////////////
    54  // Uint16 Little Endian
    55  ///////////////////////////////////////////////////////////////////////////////////////////////
    56  
    57  //goland:noinspection GoVetUnsafePointer
    58  func (p Pointer) Uint16LE(offset int) uint16 {
    59  	return bits.ReverseBytes16(*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset))))
    60  }
    61  
    62  //goland:noinspection GoVetUnsafePointer
    63  func (p Pointer) SetUint16LE(offset int, v uint16) {
    64  	*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset))) = bits.ReverseBytes16(v)
    65  }
    66  
    67  ///////////////////////////////////////////////////////////////////////////////////////////////
    68  // Int32 Big Endian
    69  ///////////////////////////////////////////////////////////////////////////////////////////////
    70  
    71  //goland:noinspection GoVetUnsafePointer
    72  func (p Pointer) Int32BE(offset int) int32 {
    73  	return *(*int32)(unsafe.Pointer(uintptr(int(p) + offset)))
    74  }
    75  
    76  //goland:noinspection GoVetUnsafePointer
    77  func (p Pointer) SetInt32BE(offset int, v int32) {
    78  	*(*int32)(unsafe.Pointer(uintptr(int(p) + offset))) = v
    79  }
    80  
    81  ///////////////////////////////////////////////////////////////////////////////////////////////
    82  // Int32 Little Endian
    83  ///////////////////////////////////////////////////////////////////////////////////////////////
    84  
    85  //goland:noinspection GoVetUnsafePointer
    86  func (p Pointer) Int32LE(offset int) int32 {
    87  	return int32(bits.ReverseBytes32(*(*uint32)(unsafe.Pointer(p + Pointer(offset)))))
    88  }
    89  
    90  //goland:noinspection GoVetUnsafePointer
    91  func (p Pointer) SetInt32LE(offset int, v int32) {
    92  	*(*int32)(unsafe.Pointer(uintptr(int(p) + offset))) = int32(bits.ReverseBytes32(uint32(v)))
    93  }
    94  
    95  ///////////////////////////////////////////////////////////////////////////////////////////////
    96  // Uint32 Big Endian
    97  ///////////////////////////////////////////////////////////////////////////////////////////////
    98  
    99  //goland:noinspection GoVetUnsafePointer
   100  func (p Pointer) Uint32BE(offset int) uint32 {
   101  	return *(*uint32)(unsafe.Pointer(uintptr(int(p) + offset)))
   102  }
   103  
   104  //goland:noinspection GoVetUnsafePointer
   105  func (p Pointer) SetUint32BE(offset int, v uint32) {
   106  	*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   107  }
   108  
   109  ///////////////////////////////////////////////////////////////////////////////////////////////
   110  // Uint32 Little Endian
   111  ///////////////////////////////////////////////////////////////////////////////////////////////
   112  
   113  //goland:noinspection GoVetUnsafePointer
   114  func (p Pointer) Uint32LE(offset int) uint32 {
   115  	return bits.ReverseBytes32(*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset))))
   116  }
   117  
   118  //goland:noinspection GoVetUnsafePointer
   119  func (p Pointer) SetUint32LE(offset int, v uint32) {
   120  	*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset))) = bits.ReverseBytes32(v)
   121  }
   122  
   123  ///////////////////////////////////////////////////////////////////////////////////////////////
   124  // Int64 Big Endian
   125  ///////////////////////////////////////////////////////////////////////////////////////////////
   126  
   127  //goland:noinspection GoVetUnsafePointer
   128  func (p Pointer) Int64BE(offset int) int64 {
   129  	return *(*int64)(unsafe.Pointer(uintptr(int(p) + offset)))
   130  }
   131  
   132  //goland:noinspection GoVetUnsafePointer
   133  func (p Pointer) SetInt64BE(offset int, v int64) {
   134  	*(*int64)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   135  }
   136  
   137  ///////////////////////////////////////////////////////////////////////////////////////////////
   138  // Int64 Little Endian
   139  ///////////////////////////////////////////////////////////////////////////////////////////////
   140  
   141  //goland:noinspection GoVetUnsafePointer
   142  func (p Pointer) Int64LE(offset int) int64 {
   143  	return int64(bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset)))))
   144  }
   145  
   146  //goland:noinspection GoVetUnsafePointer
   147  func (p Pointer) SetInt64LE(offset int, v int64) {
   148  	*(*int64)(unsafe.Pointer(uintptr(int(p) + offset))) = int64(bits.ReverseBytes64(uint64(v)))
   149  }
   150  
   151  ///////////////////////////////////////////////////////////////////////////////////////////////
   152  // Uint64 Big Endian
   153  ///////////////////////////////////////////////////////////////////////////////////////////////
   154  
   155  //goland:noinspection GoVetUnsafePointer
   156  func (p Pointer) Uint64BE(offset int) uint64 {
   157  	return *(*uint64)(unsafe.Pointer(uintptr(int(p) + offset)))
   158  }
   159  
   160  //goland:noinspection GoVetUnsafePointer
   161  func (p Pointer) SetUint64BE(offset int, v uint64) {
   162  	*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   163  }
   164  
   165  ///////////////////////////////////////////////////////////////////////////////////////////////
   166  // Uint64 Little Endian
   167  ///////////////////////////////////////////////////////////////////////////////////////////////
   168  
   169  //goland:noinspection GoVetUnsafePointer
   170  func (p Pointer) Uint64LE(offset int) uint64 {
   171  	return bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset))))
   172  }
   173  
   174  //goland:noinspection GoVetUnsafePointer
   175  func (p Pointer) SetUint64LE(offset int, v uint64) {
   176  	*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset))) = bits.ReverseBytes64(v)
   177  }
   178  
   179  ///////////////////////////////////////////////////////////////////////////////////////////////
   180  // Float32 Big Endian
   181  ///////////////////////////////////////////////////////////////////////////////////////////////
   182  
   183  //goland:noinspection GoVetUnsafePointer
   184  func (p Pointer) Float32BE(offset int) float32 {
   185  	return *(*float32)(unsafe.Pointer(uintptr(int(p) + offset)))
   186  }
   187  
   188  //goland:noinspection GoVetUnsafePointer
   189  func (p Pointer) SetFloat32BE(offset int, v float32) {
   190  	*(*float32)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   191  }
   192  
   193  ///////////////////////////////////////////////////////////////////////////////////////////////
   194  // Float32 Little Endian
   195  ///////////////////////////////////////////////////////////////////////////////////////////////
   196  
   197  //goland:noinspection GoVetUnsafePointer
   198  func (p Pointer) Float32LE(offset int) float32 {
   199  	return float32(bits.ReverseBytes32(*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset)))))
   200  }
   201  
   202  //goland:noinspection GoVetUnsafePointer
   203  func (p Pointer) SetFloat32LE(offset int, v float32) {
   204  	*(*float32)(unsafe.Pointer(uintptr(int(p) + offset))) = float32(bits.ReverseBytes32(uint32(v)))
   205  }
   206  
   207  ///////////////////////////////////////////////////////////////////////////////////////////////
   208  // Float64 Big Endian
   209  ///////////////////////////////////////////////////////////////////////////////////////////////
   210  
   211  //goland:noinspection GoVetUnsafePointer
   212  func (p Pointer) Float64BE(offset int) float64 {
   213  	return *(*float64)(unsafe.Pointer(uintptr(int(p) + offset)))
   214  }
   215  
   216  //goland:noinspection GoVetUnsafePointer
   217  func (p Pointer) SetFloat64BE(offset int, v float64) {
   218  	*(*float64)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   219  }
   220  
   221  ///////////////////////////////////////////////////////////////////////////////////////////////
   222  // Float64 Little Endian
   223  ///////////////////////////////////////////////////////////////////////////////////////////////
   224  
   225  //goland:noinspection GoVetUnsafePointer
   226  func (p Pointer) Float64LE(offset int) float64 {
   227  	return float64(bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset)))))
   228  }
   229  
   230  //goland:noinspection GoVetUnsafePointer
   231  func (p Pointer) SetFloat64LE(offset int, v float64) {
   232  	*(*float64)(unsafe.Pointer(uintptr(int(p) + offset))) = float64(bits.ReverseBytes64(uint64(v)))
   233  }
   234  
   235  ///////////////////////////////////////////////////////////////////////////////////////////////
   236  // Int24 Native Endian
   237  ///////////////////////////////////////////////////////////////////////////////////////////////
   238  
   239  //goland:noinspection GoVetUnsafePointer
   240  func (p Pointer) Int24(offset int) int32 {
   241  	return p.Int24BE(offset)
   242  }
   243  
   244  //goland:noinspection GoVetUnsafePointer
   245  func (p Pointer) SetInt24(offset int, v int32) {
   246  	p.SetInt24BE(offset, v)
   247  }
   248  
   249  ///////////////////////////////////////////////////////////////////////////////////////////////
   250  // Uint24 Native Endian
   251  ///////////////////////////////////////////////////////////////////////////////////////////////
   252  
   253  //goland:noinspection GoVetUnsafePointer
   254  func (p Pointer) Uint24(offset int) uint32 {
   255  	return p.Uint24BE(offset)
   256  }
   257  
   258  //goland:noinspection GoVetUnsafePointer
   259  func (p Pointer) SetUint24(offset int, v uint32) {
   260  	p.SetUint24BE(offset, v)
   261  }
   262  
   263  ///////////////////////////////////////////////////////////////////////////////////////////////
   264  // Int40 Native Endian
   265  ///////////////////////////////////////////////////////////////////////////////////////////////
   266  
   267  //goland:noinspection GoVetUnsafePointer
   268  func (p Pointer) Int40(offset int) int64 {
   269  	return p.Int40BE(offset)
   270  }
   271  
   272  //goland:noinspection GoVetUnsafePointer
   273  func (p Pointer) SetInt40(offset int, v int64) {
   274  	p.SetInt40BE(offset, v)
   275  }
   276  
   277  ///////////////////////////////////////////////////////////////////////////////////////////////
   278  // Uint40 Native Endian
   279  ///////////////////////////////////////////////////////////////////////////////////////////////
   280  
   281  //goland:noinspection GoVetUnsafePointer
   282  func (p Pointer) Uint40(offset int) uint64 {
   283  	return p.Uint40BE(offset)
   284  }
   285  
   286  //goland:noinspection GoVetUnsafePointer
   287  func (p Pointer) SetUint40(offset int, v uint64) {
   288  	p.SetUint40BE(offset, v)
   289  }
   290  
   291  ///////////////////////////////////////////////////////////////////////////////////////////////
   292  // Int48 Native Endian
   293  ///////////////////////////////////////////////////////////////////////////////////////////////
   294  
   295  //goland:noinspection GoVetUnsafePointer
   296  func (p Pointer) Int48(offset int) int64 {
   297  	return p.Int48BE(offset)
   298  }
   299  
   300  //goland:noinspection GoVetUnsafePointer
   301  func (p Pointer) SetInt48(offset int, v int64) {
   302  	p.SetInt48BE(offset, v)
   303  }
   304  
   305  ///////////////////////////////////////////////////////////////////////////////////////////////
   306  // Uint48 Native Endian
   307  ///////////////////////////////////////////////////////////////////////////////////////////////
   308  
   309  //goland:noinspection GoVetUnsafePointer
   310  func (p Pointer) Uint48(offset int) uint64 {
   311  	return p.Uint48BE(offset)
   312  }
   313  
   314  //goland:noinspection GoVetUnsafePointer
   315  func (p Pointer) SetUint48(offset int, v uint64) {
   316  	p.SetUint48BE(offset, v)
   317  }
   318  
   319  ///////////////////////////////////////////////////////////////////////////////////////////////
   320  // Int56 Native Endian
   321  ///////////////////////////////////////////////////////////////////////////////////////////////
   322  
   323  //goland:noinspection GoVetUnsafePointer
   324  func (p Pointer) Int56(offset int) int64 {
   325  	return p.Int56BE(offset)
   326  }
   327  
   328  //goland:noinspection GoVetUnsafePointer
   329  func (p Pointer) SetInt56(offset int, v int64) {
   330  	p.SetInt56BE(offset, v)
   331  }
   332  
   333  ///////////////////////////////////////////////////////////////////////////////////////////////
   334  // Uint56 Native Endian
   335  ///////////////////////////////////////////////////////////////////////////////////////////////
   336  
   337  //goland:noinspection GoVetUnsafePointer
   338  func (p Pointer) Uint56(offset int) uint64 {
   339  	return p.Uint56BE(offset)
   340  }
   341  
   342  //goland:noinspection GoVetUnsafePointer
   343  func (p Pointer) SetUint56(offset int, v uint64) {
   344  	p.SetUint56BE(offset, v)
   345  }