github.com/pidato/unsafe@v0.1.4/memory/pointer_le.go (about)

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