You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
132 lines
2.7 KiB
132 lines
2.7 KiB
package x86_64
|
|
|
|
import (
|
|
`encoding/binary`
|
|
`errors`
|
|
`reflect`
|
|
`strconv`
|
|
`unicode/utf8`
|
|
`unsafe`
|
|
)
|
|
|
|
const (
|
|
_CC_digit = 1 << iota
|
|
_CC_ident
|
|
_CC_ident0
|
|
_CC_number
|
|
)
|
|
|
|
func ispow2(v uint64) bool {
|
|
return (v & (v - 1)) == 0
|
|
}
|
|
|
|
func isdigit(cc rune) bool {
|
|
return '0' <= cc && cc <= '9'
|
|
}
|
|
|
|
func isalpha(cc rune) bool {
|
|
return (cc >= 'a' && cc <= 'z') || (cc >= 'A' && cc <= 'Z')
|
|
}
|
|
|
|
func isident(cc rune) bool {
|
|
return cc == '_' || isalpha(cc) || isdigit(cc)
|
|
}
|
|
|
|
func isident0(cc rune) bool {
|
|
return cc == '_' || isalpha(cc)
|
|
}
|
|
|
|
func isnumber(cc rune) bool {
|
|
return (cc == 'b' || cc == 'B') ||
|
|
(cc == 'o' || cc == 'O') ||
|
|
(cc == 'x' || cc == 'X') ||
|
|
(cc >= '0' && cc <= '9') ||
|
|
(cc >= 'a' && cc <= 'f') ||
|
|
(cc >= 'A' && cc <= 'F')
|
|
}
|
|
|
|
func align(v int, n int) int {
|
|
return (((v - 1) >> n) + 1) << n
|
|
}
|
|
|
|
func append8(m *[]byte, v byte) {
|
|
*m = append(*m, v)
|
|
}
|
|
|
|
func append16(m *[]byte, v uint16) {
|
|
p := len(*m)
|
|
*m = append(*m, 0, 0)
|
|
binary.LittleEndian.PutUint16((*m)[p:], v)
|
|
}
|
|
|
|
func append32(m *[]byte, v uint32) {
|
|
p := len(*m)
|
|
*m = append(*m, 0, 0, 0, 0)
|
|
binary.LittleEndian.PutUint32((*m)[p:], v)
|
|
}
|
|
|
|
func append64(m *[]byte, v uint64) {
|
|
p := len(*m)
|
|
*m = append(*m, 0, 0, 0, 0, 0, 0, 0, 0)
|
|
binary.LittleEndian.PutUint64((*m)[p:], v)
|
|
}
|
|
|
|
func expandmm(m *[]byte, n int, v byte) {
|
|
sl := (*_GoSlice)(unsafe.Pointer(m))
|
|
nb := sl.len + n
|
|
|
|
/* grow as needed */
|
|
if nb > cap(*m) {
|
|
*m = growslice(byteType, *m, nb)
|
|
}
|
|
|
|
/* fill the new area */
|
|
memset(unsafe.Pointer(uintptr(sl.ptr) + uintptr(sl.len)), v, uintptr(n))
|
|
sl.len = nb
|
|
}
|
|
|
|
func memset(p unsafe.Pointer, c byte, n uintptr) {
|
|
if c != 0 {
|
|
memsetv(p, c, n)
|
|
} else {
|
|
memclrNoHeapPointers(p, n)
|
|
}
|
|
}
|
|
|
|
func memsetv(p unsafe.Pointer, c byte, n uintptr) {
|
|
for i := uintptr(0); i < n; i++ {
|
|
*(*byte)(unsafe.Pointer(uintptr(p) + i)) = c
|
|
}
|
|
}
|
|
|
|
func literal64(v string) (uint64, error) {
|
|
var nb int
|
|
var ch rune
|
|
var ex error
|
|
var mm [12]byte
|
|
|
|
/* unquote the runes */
|
|
for v != "" {
|
|
if ch, _, v, ex = strconv.UnquoteChar(v, '\''); ex != nil {
|
|
return 0, ex
|
|
} else if nb += utf8.EncodeRune(mm[nb:], ch); nb > 8 {
|
|
return 0, errors.New("multi-char constant too large")
|
|
}
|
|
}
|
|
|
|
/* convert to uint64 */
|
|
return *(*uint64)(unsafe.Pointer(&mm)), nil
|
|
}
|
|
|
|
var (
|
|
byteWrap = reflect.TypeOf(byte(0))
|
|
byteType = (*_GoType)(efaceOf(byteWrap).ptr)
|
|
)
|
|
|
|
//go:linkname growslice runtime.growslice
|
|
func growslice(_ *_GoType, _ []byte, _ int) []byte
|
|
|
|
//go:noescape
|
|
//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
|
|
func memclrNoHeapPointers(_ unsafe.Pointer, _ uintptr)
|