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

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