github.com/moontrade/unsafe@v0.9.1/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 }