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 }