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

     1  //go:build tinygo.wasm || 386 || amd64 || amd64p32 || arm || arm64 || loong64 || mips64le || mips64p32 || mips64p32le || mipsle || ppc64le || riscv || riscv64 || wasm
     2  // +build tinygo.wasm 386 amd64 amd64p32 arm arm64 loong64 mips64le mips64p32 mips64p32le mipsle ppc64le riscv riscv64 wasm
     3  
     4  package nogc
     5  
     6  import (
     7  	"math/bits"
     8  	"unsafe"
     9  )
    10  
    11  ///////////////////////////////////////////////////////////////////////////////////////////////
    12  // Int16 Little Endian
    13  ///////////////////////////////////////////////////////////////////////////////////////////////
    14  
    15  //goland:noinspection GoVetUnsafePointer
    16  func (p Pointer) AsInt16LE() int16 {
    17  	return *(*int16)(p.Unsafe())
    18  }
    19  
    20  //goland:noinspection GoVetUnsafePointer
    21  func (p Pointer) Int16LE(offset int) int16 {
    22  	return *(*int16)(unsafe.Pointer(uintptr(int(p) + offset)))
    23  }
    24  
    25  //goland:noinspection GoVetUnsafePointer
    26  func (p Pointer) SetInt16LE(offset int, v int16) {
    27  	*(*int16)(unsafe.Pointer(uintptr(int(p) + offset))) = v
    28  }
    29  
    30  ///////////////////////////////////////////////////////////////////////////////////////////////
    31  // Int16 Big Endian
    32  ///////////////////////////////////////////////////////////////////////////////////////////////
    33  
    34  //goland:noinspection GoVetUnsafePointer
    35  func (p Pointer) AsInt16BE() int16 {
    36  	return int16(bits.ReverseBytes16(*(*uint16)(p.Unsafe())))
    37  }
    38  
    39  //goland:noinspection GoVetUnsafePointer
    40  func (p Pointer) Int16BE(offset int) int16 {
    41  	return int16(bits.ReverseBytes16(*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset)))))
    42  }
    43  
    44  //goland:noinspection GoVetUnsafePointer
    45  func (p Pointer) SetInt16BE(offset int, v int16) {
    46  	*(*int16)(unsafe.Pointer(uintptr(int(p) + offset))) = int16(bits.ReverseBytes16(uint16(v)))
    47  }
    48  
    49  ///////////////////////////////////////////////////////////////////////////////////////////////
    50  // Uint16 Little Endian
    51  ///////////////////////////////////////////////////////////////////////////////////////////////
    52  
    53  //goland:noinspection GoVetUnsafePointer
    54  func (p Pointer) AsUint16LE() uint16 {
    55  	return *(*uint16)(p.Unsafe())
    56  }
    57  
    58  //goland:noinspection GoVetUnsafePointer
    59  func (p Pointer) Uint16LE(offset int) uint16 {
    60  	return *(*uint16)(unsafe.Pointer(uintptr(int(p) + offset)))
    61  }
    62  
    63  //goland:noinspection GoVetUnsafePointer
    64  func (p Pointer) SetUint16LE(offset int, v uint16) {
    65  	*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset))) = v
    66  }
    67  
    68  ///////////////////////////////////////////////////////////////////////////////////////////////
    69  // Uint16 Big Endian
    70  ///////////////////////////////////////////////////////////////////////////////////////////////
    71  
    72  //goland:noinspection GoVetUnsafePointer
    73  func (p Pointer) AsUint16BE() uint16 {
    74  	return bits.ReverseBytes16(*(*uint16)(p.Unsafe()))
    75  }
    76  
    77  //goland:noinspection GoVetUnsafePointer
    78  func (p Pointer) Uint16BE(offset int) uint16 {
    79  	return bits.ReverseBytes16(*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset))))
    80  }
    81  
    82  //goland:noinspection GoVetUnsafePointer
    83  func (p Pointer) SetUint16BE(offset int, v uint16) {
    84  	*(*uint16)(unsafe.Pointer(uintptr(int(p) + offset))) = bits.ReverseBytes16(v)
    85  }
    86  
    87  ///////////////////////////////////////////////////////////////////////////////////////////////
    88  // Int32 Little Endian
    89  ///////////////////////////////////////////////////////////////////////////////////////////////
    90  
    91  //goland:noinspection GoVetUnsafePointer
    92  func (p Pointer) AsInt32LE() int32 {
    93  	return *(*int32)(p.Unsafe())
    94  }
    95  
    96  //goland:noinspection GoVetUnsafePointer
    97  func (p Pointer) Int32LE(offset int) int32 {
    98  	return *(*int32)(unsafe.Pointer(uintptr(int(p) + offset)))
    99  }
   100  
   101  //goland:noinspection GoVetUnsafePointer
   102  func (p Pointer) SetInt32LE(offset int, v int32) {
   103  	*(*int32)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   104  }
   105  
   106  ///////////////////////////////////////////////////////////////////////////////////////////////
   107  // Int32 Big Endian
   108  ///////////////////////////////////////////////////////////////////////////////////////////////
   109  
   110  //goland:noinspection GoVetUnsafePointer
   111  func (p Pointer) AsInt32BE() int32 {
   112  	return int32(bits.ReverseBytes32(*(*uint32)(p.Unsafe())))
   113  }
   114  
   115  //goland:noinspection GoVetUnsafePointer
   116  func (p Pointer) Int32BE(offset int) int32 {
   117  	return int32(bits.ReverseBytes32(*(*uint32)(unsafe.Pointer(p + Pointer(offset)))))
   118  }
   119  
   120  //goland:noinspection GoVetUnsafePointer
   121  func (p Pointer) SetInt32BE(offset int, v int32) {
   122  	*(*int32)(unsafe.Pointer(uintptr(int(p) + offset))) = int32(bits.ReverseBytes32(uint32(v)))
   123  }
   124  
   125  ///////////////////////////////////////////////////////////////////////////////////////////////
   126  // Uint32 Little Endian
   127  ///////////////////////////////////////////////////////////////////////////////////////////////
   128  
   129  //goland:noinspection GoVetUnsafePointer
   130  func (p Pointer) AsUint32LE() uint32 {
   131  	return *(*uint32)(p.Unsafe())
   132  }
   133  
   134  //goland:noinspection GoVetUnsafePointer
   135  func (p Pointer) Uint32LE(offset int) uint32 {
   136  	return *(*uint32)(unsafe.Pointer(uintptr(int(p) + offset)))
   137  }
   138  
   139  //goland:noinspection GoVetUnsafePointer
   140  func (p Pointer) SetUint32LE(offset int, v uint32) {
   141  	*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   142  }
   143  
   144  ///////////////////////////////////////////////////////////////////////////////////////////////
   145  // Uint32 Big Endian
   146  ///////////////////////////////////////////////////////////////////////////////////////////////
   147  
   148  //goland:noinspection GoVetUnsafePointer
   149  func (p Pointer) Uint32BESlow() uint32 {
   150  	return uint32(*(*byte)(unsafe.Pointer(p + 3))) |
   151  		uint32(*(*byte)(unsafe.Pointer(p + 2)))<<8 |
   152  		uint32(*(*byte)(unsafe.Pointer(p + 1)))<<16 |
   153  		uint32(*(*byte)(unsafe.Pointer(p)))<<24
   154  }
   155  
   156  //goland:noinspection GoVetUnsafePointer
   157  func (p Pointer) AsUint32BE() uint32 {
   158  	return bits.ReverseBytes32(*(*uint32)(p.Unsafe()))
   159  }
   160  
   161  //goland:noinspection GoVetUnsafePointer
   162  func (p Pointer) Uint32BE(offset int) uint32 {
   163  	return bits.ReverseBytes32(*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset))))
   164  }
   165  
   166  //goland:noinspection GoVetUnsafePointer
   167  func (p Pointer) SetUint32BE(offset int, v uint32) {
   168  	*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset))) = bits.ReverseBytes32(v)
   169  }
   170  
   171  ///////////////////////////////////////////////////////////////////////////////////////////////
   172  // Int64 Little Endian
   173  ///////////////////////////////////////////////////////////////////////////////////////////////
   174  
   175  //goland:noinspection GoVetUnsafePointer
   176  func (p Pointer) AsInt64LE() int64 {
   177  	return *(*int64)(p.Unsafe())
   178  }
   179  
   180  //goland:noinspection GoVetUnsafePointer
   181  func (p Pointer) Int64LE(offset int) int64 {
   182  	return *(*int64)(unsafe.Pointer(uintptr(int(p) + offset)))
   183  }
   184  
   185  //goland:noinspection GoVetUnsafePointer
   186  func (p Pointer) SetInt64LE(offset int, v int64) {
   187  	*(*int64)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   188  }
   189  
   190  ///////////////////////////////////////////////////////////////////////////////////////////////
   191  // Int64 Big Endian
   192  ///////////////////////////////////////////////////////////////////////////////////////////////
   193  
   194  //goland:noinspection GoVetUnsafePointer
   195  func (p Pointer) AsInt64BE() int64 {
   196  	return int64(bits.ReverseBytes64(*(*uint64)(p.Unsafe())))
   197  }
   198  
   199  //goland:noinspection GoVetUnsafePointer
   200  func (p Pointer) Int64BE(offset int) int64 {
   201  	return int64(bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset)))))
   202  }
   203  
   204  //goland:noinspection GoVetUnsafePointer
   205  func (p Pointer) SetInt64BE(offset int, v int64) {
   206  	*(*int64)(unsafe.Pointer(uintptr(int(p) + offset))) = int64(bits.ReverseBytes64(uint64(v)))
   207  }
   208  
   209  ///////////////////////////////////////////////////////////////////////////////////////////////
   210  // Uint64 Little Endian
   211  ///////////////////////////////////////////////////////////////////////////////////////////////
   212  
   213  //goland:noinspection GoVetUnsafePointer
   214  func (p Pointer) AsUint64LE() uint64 {
   215  	return *(*uint64)(unsafe.Pointer(p))
   216  }
   217  
   218  //goland:noinspection GoVetUnsafePointer
   219  func (p Pointer) Uint64LE(offset int) uint64 {
   220  	return *(*uint64)(unsafe.Pointer(uintptr(int(p) + offset)))
   221  }
   222  
   223  //goland:noinspection GoVetUnsafePointer
   224  func (p Pointer) SetUint64LE(offset int, v uint64) {
   225  	*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   226  }
   227  
   228  ///////////////////////////////////////////////////////////////////////////////////////////////
   229  // Uint64 Big Endian
   230  ///////////////////////////////////////////////////////////////////////////////////////////////
   231  
   232  //goland:noinspection GoVetUnsafePointer
   233  func (p Pointer) AsUint64BE() uint64 {
   234  	return bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(p)))
   235  }
   236  
   237  //goland:noinspection GoVetUnsafePointer
   238  func (p Pointer) Uint64BE(offset int) uint64 {
   239  	return bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset))))
   240  }
   241  
   242  //goland:noinspection GoVetUnsafePointer
   243  func (p Pointer) SetUint64BE(offset int, v uint64) {
   244  	*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset))) = bits.ReverseBytes64(v)
   245  }
   246  
   247  ///////////////////////////////////////////////////////////////////////////////////////////////
   248  // Float32 Little Endian
   249  ///////////////////////////////////////////////////////////////////////////////////////////////
   250  
   251  //goland:noinspection GoVetUnsafePointer
   252  func (p Pointer) AsFloat32LE() float32 {
   253  	return *(*float32)(unsafe.Pointer(p))
   254  }
   255  
   256  //goland:noinspection GoVetUnsafePointer
   257  func (p Pointer) Float32LE(offset int) float32 {
   258  	return *(*float32)(unsafe.Pointer(uintptr(int(p) + offset)))
   259  }
   260  
   261  //goland:noinspection GoVetUnsafePointer
   262  func (p Pointer) SetFloat32LE(offset int, v float32) {
   263  	*(*float32)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   264  }
   265  
   266  ///////////////////////////////////////////////////////////////////////////////////////////////
   267  // Float32 Big Endian
   268  ///////////////////////////////////////////////////////////////////////////////////////////////
   269  
   270  //goland:noinspection GoVetUnsafePointer
   271  func (p Pointer) AsFloat32BE() float32 {
   272  	return float32(bits.ReverseBytes32(*(*uint32)(unsafe.Pointer(p))))
   273  }
   274  
   275  //goland:noinspection GoVetUnsafePointer
   276  func (p Pointer) Float32BE(offset int) float32 {
   277  	return float32(bits.ReverseBytes32(*(*uint32)(unsafe.Pointer(uintptr(int(p) + offset)))))
   278  }
   279  
   280  //goland:noinspection GoVetUnsafePointer
   281  func (p Pointer) SetFloat32BE(offset int, v float32) {
   282  	*(*float32)(unsafe.Pointer(uintptr(int(p) + offset))) = float32(bits.ReverseBytes32(uint32(v)))
   283  }
   284  
   285  ///////////////////////////////////////////////////////////////////////////////////////////////
   286  // Float64 Little Endian
   287  ///////////////////////////////////////////////////////////////////////////////////////////////
   288  
   289  //goland:noinspection GoVetUnsafePointer
   290  func (p Pointer) AsFloat64LE() float64 {
   291  	return *(*float64)(unsafe.Pointer(p))
   292  }
   293  
   294  //goland:noinspection GoVetUnsafePointer
   295  func (p Pointer) Float64LE(offset int) float64 {
   296  	return *(*float64)(unsafe.Pointer(uintptr(int(p) + offset)))
   297  }
   298  
   299  //goland:noinspection GoVetUnsafePointer
   300  func (p Pointer) SetFloat64LE(offset int, v float64) {
   301  	*(*float64)(unsafe.Pointer(uintptr(int(p) + offset))) = v
   302  }
   303  
   304  ///////////////////////////////////////////////////////////////////////////////////////////////
   305  // Float64 Big Endian
   306  ///////////////////////////////////////////////////////////////////////////////////////////////
   307  
   308  //goland:noinspection GoVetUnsafePointer
   309  func (p Pointer) AsFloat64BE() float64 {
   310  	return float64(bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(p))))
   311  }
   312  
   313  //goland:noinspection GoVetUnsafePointer
   314  func (p Pointer) Float64BE(offset int) float64 {
   315  	return float64(bits.ReverseBytes64(*(*uint64)(unsafe.Pointer(uintptr(int(p) + offset)))))
   316  }
   317  
   318  //goland:noinspection GoVetUnsafePointer
   319  func (p Pointer) SetFloat64BE(offset int, v float64) {
   320  	*(*float64)(unsafe.Pointer(uintptr(int(p) + offset))) = float64(bits.ReverseBytes64(uint64(v)))
   321  }
   322  
   323  ///////////////////////////////////////////////////////////////////////////////////////////////
   324  // Int24 Native Endian
   325  ///////////////////////////////////////////////////////////////////////////////////////////////
   326  
   327  //goland:noinspection GoVetUnsafePointer
   328  func (p Pointer) Int24(offset int) int32 {
   329  	return p.Int24LE(offset)
   330  }
   331  
   332  //goland:noinspection GoVetUnsafePointer
   333  func (p Pointer) SetInt24(offset int, v int32) {
   334  	p.SetInt24LE(offset, v)
   335  }
   336  
   337  ///////////////////////////////////////////////////////////////////////////////////////////////
   338  // Uint24 Native Endian
   339  ///////////////////////////////////////////////////////////////////////////////////////////////
   340  
   341  //goland:noinspection GoVetUnsafePointer
   342  func (p Pointer) Uint24(offset int) uint32 {
   343  	return p.Uint24LE(offset)
   344  }
   345  
   346  //goland:noinspection GoVetUnsafePointer
   347  func (p Pointer) SetUint24(offset int, v uint32) {
   348  	p.SetUint24LE(offset, v)
   349  }
   350  
   351  ///////////////////////////////////////////////////////////////////////////////////////////////
   352  // Int40 Native Endian
   353  ///////////////////////////////////////////////////////////////////////////////////////////////
   354  
   355  //goland:noinspection GoVetUnsafePointer
   356  func (p Pointer) Int40(offset int) int64 {
   357  	return p.Int40LE(offset)
   358  }
   359  
   360  //goland:noinspection GoVetUnsafePointer
   361  func (p Pointer) SetInt40(offset int, v int64) {
   362  	p.SetInt40LE(offset, v)
   363  }
   364  
   365  ///////////////////////////////////////////////////////////////////////////////////////////////
   366  // Uint40 Native Endian
   367  ///////////////////////////////////////////////////////////////////////////////////////////////
   368  
   369  //goland:noinspection GoVetUnsafePointer
   370  func (p Pointer) Uint40(offset int) uint64 {
   371  	return p.Uint40LE(offset)
   372  }
   373  
   374  //goland:noinspection GoVetUnsafePointer
   375  func (p Pointer) SetUint40(offset int, v uint64) {
   376  	p.SetUint40LE(offset, v)
   377  }
   378  
   379  ///////////////////////////////////////////////////////////////////////////////////////////////
   380  // Int48 Native Endian
   381  ///////////////////////////////////////////////////////////////////////////////////////////////
   382  
   383  //goland:noinspection GoVetUnsafePointer
   384  func (p Pointer) Int48(offset int) int64 {
   385  	return p.Int48LE(offset)
   386  }
   387  
   388  //goland:noinspection GoVetUnsafePointer
   389  func (p Pointer) SetInt48(offset int, v int64) {
   390  	p.SetInt48LE(offset, v)
   391  }
   392  
   393  ///////////////////////////////////////////////////////////////////////////////////////////////
   394  // Uint48 Native Endian
   395  ///////////////////////////////////////////////////////////////////////////////////////////////
   396  
   397  //goland:noinspection GoVetUnsafePointer
   398  func (p Pointer) Uint48(offset int) uint64 {
   399  	return p.Uint48LE(offset)
   400  }
   401  
   402  //goland:noinspection GoVetUnsafePointer
   403  func (p Pointer) SetUint48(offset int, v uint64) {
   404  	p.SetUint48LE(offset, v)
   405  }
   406  
   407  ///////////////////////////////////////////////////////////////////////////////////////////////
   408  // Int56 Native Endian
   409  ///////////////////////////////////////////////////////////////////////////////////////////////
   410  
   411  //goland:noinspection GoVetUnsafePointer
   412  func (p Pointer) Int56(offset int) int64 {
   413  	return p.Int56LE(offset)
   414  }
   415  
   416  //goland:noinspection GoVetUnsafePointer
   417  func (p Pointer) SetInt56(offset int, v int64) {
   418  	p.SetInt56LE(offset, v)
   419  }
   420  
   421  ///////////////////////////////////////////////////////////////////////////////////////////////
   422  // Uint56 Native Endian
   423  ///////////////////////////////////////////////////////////////////////////////////////////////
   424  
   425  //goland:noinspection GoVetUnsafePointer
   426  func (p Pointer) Uint56(offset int) uint64 {
   427  	return p.Uint56LE(offset)
   428  }
   429  
   430  //goland:noinspection GoVetUnsafePointer
   431  func (p Pointer) SetUint56(offset int, v uint64) {
   432  	p.SetUint56LE(offset, v)
   433  }