codecin 5.4.2__py3-none-any.whl

codecin/native/engine/audio.go

@@ -0,0 +1,152 @@
+package engine
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// 联网音频: 下载 (http/https) 或本地文件 → 解析 WAV → 平台播放。
+// 支持格式: WAV (PCM)。MP3/OGG 需外部解码器, 本实现不包含。
+//
+// 平台播放后端由构建约束拆分:
+//   audio_windows.go (//go:build windows)   —— winmm PlaySoundW
+//   audio_other.go   (//go:build !windows)  —— afplay / aplay / paplay / ffplay
+
+// 宿主全局音频状态 (同一时刻一个音频流)。
+var (
+	audioActive  bool
+	audioDur     time.Duration
+	audioEnd     time.Time
+	audioTemp    string // 当前播放的临时 WAV 文件路径 (异步播放时保留)
+	audioCmd     *exec.Cmd
+	audioStarted time.Time
+)
+
+// MaxResourceBytes 是 FetchResource 的下载/读取上限 (音频等宿主资源)。
+const MaxResourceBytes = 64 << 20 // 64 MiB
+
+// FetchResource 下载 URL 或读取本地文件, 返回原始字节。
+func FetchResource(loc string) ([]byte, error) {
+	if strings.HasPrefix(loc, "http://") || strings.HasPrefix(loc, "https://") {
+		client := &http.Client{Timeout: 30 * time.Second}
+		resp, err := client.Get(loc)
+		if err != nil {
+			return nil, err
+		}
+		defer resp.Body.Close()
+		if resp.StatusCode != http.StatusOK {
+			return nil, fmt.Errorf("http status %d", resp.StatusCode)
+		}
+		// 有上限读取: Content-Length 与实际读取量双重限制,
+		// 防止恶意/异常 URL 用无限流把宿主 OOM。
+		if resp.ContentLength > MaxResourceBytes {
+			return nil, fmt.Errorf("resource too large: %d bytes", resp.ContentLength)
+		}
+		data, err := io.ReadAll(io.LimitReader(resp.Body, MaxResourceBytes+1))
+		if err != nil {
+			return nil, err
+		}
+		if len(data) > MaxResourceBytes {
+			return nil, fmt.Errorf("resource too large: >%d bytes", MaxResourceBytes)
+		}
+		return data, nil
+	}
+	fi, err := os.Stat(loc)
+	if err == nil && fi.Size() > MaxResourceBytes {
+		return nil, fmt.Errorf("resource too large: %d bytes", fi.Size())
+	}
+	return os.ReadFile(loc)
+}
+
+// WavDuration 解析 WAV 头并返回时长 (0 表示无法识别)。
+func WavDuration(data []byte) time.Duration {
+	if len(data) < 44 || string(data[0:4]) != "RIFF" || string(data[8:12]) != "WAVE" {
+		return 0
+	}
+	byteRate := binary.LittleEndian.Uint32(data[28:32])
+	dataSize := binary.LittleEndian.Uint32(data[40:44])
+	if byteRate == 0 {
+		return 0
+	}
+	return time.Duration(float64(dataSize) / float64(byteRate) * float64(time.Second))
+}
+
+// isWav 判断是否为 WAV (RIFF/WAVE)。
+func isWav(data []byte) bool {
+	return len(data) >= 12 && string(data[0:4]) == "RIFF" && string(data[8:12]) == "WAVE"
+}
+
+// writeTempWav 将 WAV 字节写入临时文件并记录路径。
+func writeTempWav(data []byte) (string, error) {
+	f, err := os.CreateTemp("", "codecin_*.wav")
+	if err != nil {
+		return "", err
+	}
+	if _, err := f.Write(data); err != nil {
+		_ = f.Close()
+		_ = os.Remove(f.Name())
+		return "", err
+	}
+	if err := f.Close(); err != nil {
+		_ = os.Remove(f.Name())
+		return "", err
+	}
+	audioTemp = f.Name()
+	return audioTemp, nil
+}
+
+// cleanupTempWav 删除临时 WAV 文件。
+func cleanupTempWav() {
+	if audioTemp != "" {
+		_ = os.Remove(audioTemp)
+		audioTemp = ""
+	}
+}
+
+func (vm *vmState) audioPlay(loc string) uint64 {
+	data, err := FetchResource(loc)
+	if err != nil {
+		return mask64 // -1
+	}
+	if !isWav(data) {
+		return mask64 // 不支持的格式
+	}
+	if err := playPlatform(data); err != nil {
+		return mask64
+	}
+	audioActive = true
+	audioDur = WavDuration(data)
+	audioStarted = time.Now()
+	audioEnd = audioStarted.Add(audioDur)
+	return 0
+}
+
+func (vm *vmState) audioStop() {
+	audioActive = false
+	stopPlatform()
+}
+
+func (vm *vmState) audioVolume(level uint64) {
+	// 音量控制依赖 OS 混音器, 本实现忽略 (保留参数以便后续扩展)。
+	_ = level
+}
+
+func (vm *vmState) audioWait() {
+	if !audioActive {
+		return
+	}
+	if audioDur <= 0 {
+		return
+	}
+	remain := time.Until(audioEnd)
+	if remain > 0 {
+		time.Sleep(remain)
+	}
+	audioActive = false
+}

codecin/native/engine/audio_other.go

@@ -0,0 +1,46 @@
+//go:build !windows
+
+package engine
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+)
+
+// Unix 音频后端 (Linux / macOS / Termux / BSD): 调用系统播放器。
+//   macOS: afplay
+//   Linux/Termux: aplay / paplay / ffplay (取第一个可用者)
+
+func playPlatform(data []byte) error {
+	path, err := writeTempWav(data)
+	if err != nil {
+		return err
+	}
+
+	if runtime.GOOS == "darwin" {
+		audioCmd = exec.Command("afplay", path)
+		return audioCmd.Start()
+	}
+
+	for _, p := range []string{"aplay", "paplay", "ffplay"} {
+		if _, err := exec.LookPath(p); err != nil {
+			continue
+		}
+		if p == "ffplay" {
+			audioCmd = exec.Command(p, "-nodisp", "-autoexit", "-loglevel", "quiet", path)
+		} else {
+			audioCmd = exec.Command(p, path)
+		}
+		return audioCmd.Start()
+	}
+	return fmt.Errorf("no audio player found (aplay/paplay/ffplay)")
+}
+
+func stopPlatform() {
+	if audioCmd != nil && audioCmd.Process != nil {
+		_ = audioCmd.Process.Kill()
+	}
+	audioCmd = nil
+	cleanupTempWav()
+}

codecin/native/engine/audio_windows.go

@@ -0,0 +1,43 @@
+//go:build windows
+
+package engine
+
+import (
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+// Windows 音频后端: winmm.dll PlaySoundW (异步)。
+
+var (
+	winmm      = syscall.NewLazyDLL("winmm.dll")
+	playSoundW = winmm.NewProc("PlaySoundW")
+)
+
+const (
+	sndAsync    = 0x0001
+	sndPurge    = 0x0040
+	sndFilename = 0x00020000
+)
+
+func playPlatform(data []byte) error {
+	path, err := writeTempWav(data)
+	if err != nil {
+		return err
+	}
+	p, err := syscall.UTF16PtrFromString(path)
+	if err != nil {
+		return err
+	}
+	r, _, _ := playSoundW.Call(uintptr(unsafe.Pointer(p)), 0, sndFilename|sndAsync)
+	if r == 0 {
+		return fmt.Errorf("PlaySoundW failed")
+	}
+	return nil
+}
+
+func stopPlatform() {
+	playSoundW.Call(0, 0, sndPurge)
+	cleanupTempWav()
+}

codecin/native/engine/canvas.go

@@ -0,0 +1,271 @@
+package engine
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"image/png"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+)
+
+// 2D 绘图画布 (Go 标准库 image/png 实现): 新建画布 → 着色 → 绘制形状/文本 → 导出 PNG。
+// 宿主全局状态: 同一时刻一个「当前画布」与「当前颜色」。
+
+var (
+	curCanvas *image.RGBA
+	curColor  = color.RGBA{R: 0, G: 0, B: 0, A: 255} // 默认黑色画笔
+)
+
+func clampCoord(v uint64) int {
+	if v > 100000 {
+		return 100000
+	}
+	return int(v)
+}
+
+func (vm *vmState) canvasNew(w, h uint64) {
+	cw, ch := clampCoord(w), clampCoord(h)
+	if cw < 1 {
+		cw = 1
+	}
+	if ch < 1 {
+		ch = 1
+	}
+	curCanvas = image.NewRGBA(image.Rect(0, 0, cw, ch))
+	// 白色背景
+	for i := range curCanvas.Pix {
+		curCanvas.Pix[i] = 255
+	}
+	curColor = color.RGBA{R: 0, G: 0, B: 0, A: 255}
+}
+
+func (vm *vmState) canvasSetColor(rgb uint64) {
+	curColor = color.RGBA{
+		R: uint8((rgb >> 16) & 0xFF),
+		G: uint8((rgb >> 8) & 0xFF),
+		B: uint8(rgb & 0xFF),
+		A: 255,
+	}
+}
+
+func (vm *vmState) canvasRect(x, y, w, h uint64) {
+	if curCanvas == nil {
+		return
+	}
+	x0, y0 := clampCoord(x), clampCoord(y)
+	x1, y1 := x0+clampCoord(w), y0+clampCoord(h)
+	b := curCanvas.Bounds()
+	if x0 < b.Min.X {
+		x0 = b.Min.X
+	}
+	if y0 < b.Min.Y {
+		y0 = b.Min.Y
+	}
+	if x1 > b.Max.X {
+		x1 = b.Max.X
+	}
+	if y1 > b.Max.Y {
+		y1 = b.Max.Y
+	}
+	for py := y0; py < y1; py++ {
+		for px := x0; px < x1; px++ {
+			curCanvas.SetRGBA(px, py, curColor)
+		}
+	}
+}
+
+func (vm *vmState) canvasCircle(cx, cy, r uint64) {
+	if curCanvas == nil {
+		return
+	}
+	ccx, ccy := clampCoord(cx), clampCoord(cy)
+	rr := clampCoord(r)
+	rr2 := rr * rr
+	b := curCanvas.Bounds()
+	for py := ccy - rr; py <= ccy+rr; py++ {
+		for px := ccx - rr; px <= ccx+rr; px++ {
+			dx := px - ccx
+			dy := py - ccy
+			if dx*dx+dy*dy <= rr2 {
+				if px >= b.Min.X && px < b.Max.X && py >= b.Min.Y && py < b.Max.Y {
+					curCanvas.SetRGBA(px, py, curColor)
+				}
+			}
+		}
+	}
+}
+
+func (vm *vmState) canvasLine(x0, y0, x1, y1 uint64) {
+	if curCanvas == nil {
+		return
+	}
+	ax, ay := clampCoord(x0), clampCoord(y0)
+	bx, by := clampCoord(x1), clampCoord(y1)
+	b := curCanvas.Bounds()
+	// Bresenham
+	dx := bx - ax
+	if dx < 0 {
+		dx = -dx
+	}
+	sx := 1
+	if ax > bx {
+		sx = -1
+	}
+	dy := by - ay
+	if dy < 0 {
+		dy = -dy
+	}
+	sy := 1
+	if ay > by {
+		sy = -1
+	}
+	err := dx - dy
+	for {
+		if ax >= b.Min.X && ax < b.Max.X && ay >= b.Min.Y && ay < b.Max.Y {
+			curCanvas.SetRGBA(ax, ay, curColor)
+		}
+		if ax == bx && ay == by {
+			break
+		}
+		e2 := 2 * err
+		if e2 > -dy {
+			err -= dy
+			ax += sx
+		}
+		if e2 < dx {
+			err += dx
+			ay += sy
+		}
+	}
+}
+
+// font5x7: 内置 5x7 点阵字库 (ASCII 数字/大写/常用标点; 小写映射为大写)。
+type glyph [7]string
+
+var font5x7 = map[rune]glyph{
+	' ': {"     ", "     ", "     ", "     ", "     ", "     ", "     "},
+	'0': {" ### ", "#   #", "#  ##", "# # #", "##  #", "#   #", " ### "},
+	'1': {"  #  ", " ##  ", "  #  ", "  #  ", "  #  ", "  #  ", " ### "},
+	'2': {" ### ", "#   #", "    #", "   # ", "  #  ", " #   ", "#####"},
+	'3': {"#####", "    #", "   # ", "  ## ", "    #", "#   #", " ### "},
+	'4': {"   # ", "  ## ", " # # ", "#  # ", "#####", "   # ", "   # "},
+	'5': {"#####", "#    ", "#### ", "    #", "    #", "#   #", " ### "},
+	'6': {"  ## ", " #   ", "#    ", "#### ", "#   #", "#   #", " ### "},
+	'7': {"#####", "    #", "   # ", "  #  ", " #   ", " #   ", " #   "},
+	'8': {" ### ", "#   #", "#   #", " ### ", "#   #", "#   #", " ### "},
+	'9': {" ### ", "#   #", "#   #", " ####", "    #", "   # ", " ##  "},
+	'A': {" ### ", "#   #", "#   #", "#####", "#   #", "#   #", "#   #"},
+	'B': {"#### ", "#   #", "#   #", "#### ", "#   #", "#   #", "#### "},
+	'C': {" ### ", "#   #", "#    ", "#    ", "#    ", "#   #", " ### "},
+	'D': {"#### ", "#   #", "#   #", "#   #", "#   #", "#   #", "#### "},
+	'E': {"#####", "#    ", "#    ", "#### ", "#    ", "#    ", "#####"},
+	'F': {"#####", "#    ", "#    ", "#### ", "#    ", "#    ", "#    "},
+	'G': {" ### ", "#   #", "#    ", "# ###", "#   #", "#   #", " ####"},
+	'H': {"#   #", "#   #", "#   #", "#####", "#   #", "#   #", "#   #"},
+	'I': {" ### ", "  #  ", "  #  ", "  #  ", "  #  ", "  #  ", " ### "},
+	'J': {"    #", "    #", "    #", "    #", "#   #", "#   #", " ### "},
+	'K': {"#   #", "#  # ", "# #  ", "##   ", "# #  ", "#  # ", "#   #"},
+	'L': {"#    ", "#    ", "#    ", "#    ", "#    ", "#    ", "#####"},
+	'M': {"#   #", "## ##", "# # #", "# # #", "#   #", "#   #", "#   #"},
+	'N': {"#   #", "##  #", "# # #", "#  ##", "#   #", "#   #", "#   #"},
+	'O': {" ### ", "#   #", "#   #", "#   #", "#   #", "#   #", " ### "},
+	'P': {"#### ", "#   #", "#   #", "#### ", "#    ", "#    ", "#    "},
+	'Q': {" ### ", "#   #", "#   #", "#   #", "# # #", "#  # ", " ## #"},
+	'R': {"#### ", "#   #", "#   #", "#### ", "# #  ", "#  # ", "#   #"},
+	'S': {" ####", "#    ", "#    ", " ### ", "    #", "    #", "#### "},
+	'T': {"#####", "  #  ", "  #  ", "  #  ", "  #  ", "  #  ", "  #  "},
+	'U': {"#   #", "#   #", "#   #", "#   #", "#   #", "#   #", " ### "},
+	'V': {"#   #", "#   #", "#   #", "#   #", "#   #", " # # ", "  #  "},
+	'W': {"#   #", "#   #", "#   #", "# # #", "# # #", "## ##", "#   #"},
+	'X': {"#   #", "#   #", " # # ", "  #  ", " # # ", "#   #", "#   #"},
+	'Y': {"#   #", "#   #", " # # ", "  #  ", "  #  ", "  #  ", "  #  "},
+	'Z': {"#####", "    #", "   # ", "  #  ", " #   ", "#    ", "#####"},
+	'.': {"     ", "     ", "     ", "     ", "     ", " ##  ", " ##  "},
+	',': {"     ", "     ", "     ", "     ", "  ## ", "  #  ", " #   "},
+	':': {"     ", "  ## ", "  ## ", "     ", "  ## ", "  ## ", "     "},
+	'-': {"     ", "     ", "     ", "#####", "     ", "     ", "     "},
+	'!': {"  #  ", "  #  ", "  #  ", "  #  ", "  #  ", "     ", "  #  "},
+	'?': {" ### ", "#   #", "    #", "   # ", "  #  ", "     ", "  #  "},
+	'/': {"    #", "    #", "   # ", "  #  ", " #   ", "#    ", "#    "},
+}
+
+func (vm *vmState) canvasText(x, y uint64, s string) {
+	if curCanvas == nil {
+		return
+	}
+	ox, oy := clampCoord(x), clampCoord(y)
+	s = strings.ToUpper(s)
+	b := curCanvas.Bounds()
+	px := ox
+	for _, r := range s {
+		g, ok := font5x7[r]
+		if !ok {
+			g = font5x7['?']
+		}
+		for row := 0; row < 7; row++ {
+			for col := 0; col < 5; col++ {
+				if g[row][col] == '#' {
+					cx := px + col
+					cy := oy + row
+					if cx >= b.Min.X && cx < b.Max.X && cy >= b.Min.Y && cy < b.Max.Y {
+						curCanvas.SetRGBA(cx, cy, curColor)
+					}
+				}
+			}
+		}
+		px += 6
+	}
+}
+
+func (vm *vmState) canvasSave(path string) uint64 {
+	if curCanvas == nil {
+		return mask64 // -1
+	}
+	f, err := os.Create(path)
+	if err != nil {
+		return mask64
+	}
+	defer f.Close()
+	if err := png.Encode(f, curCanvas); err != nil {
+		return mask64
+	}
+	return 0
+}
+
+// canvasShow 保存当前画布到临时 PNG 并用系统查看器打开 (跨平台 "窗口")。
+func (vm *vmState) canvasShow() uint64 {
+	if curCanvas == nil {
+		return mask64 // -1
+	}
+	path := filepath.Join(os.TempDir(),
+		fmt.Sprintf("codecin_canvas_%d.png", time.Now().UnixNano()))
+	f, err := os.Create(path)
+	if err != nil {
+		return mask64
+	}
+	if err := png.Encode(f, curCanvas); err != nil {
+		_ = f.Close()
+		return mask64
+	}
+	_ = f.Close()
+	openViewer(path)
+	return 0
+}
+
+func openViewer(path string) {
+	var cmd *exec.Cmd
+	switch runtime.GOOS {
+	case "windows":
+		cmd = exec.Command("cmd", "/c", "start", "", path)
+	case "darwin":
+		cmd = exec.Command("open", path)
+	default:
+		cmd = exec.Command("xdg-open", path)
+	}
+	_ = cmd.Start()
+}

codecin/native/engine/crom.go

@@ -0,0 +1,86 @@
+package engine
+
+// CROM v3: magic 'CROM' + version u8 + mem_size u32 + flags u8 + crc32 u32
+//        + 2B reserved + payload (zlib 默认压缩, 与 Python zlib level 6 兼容)
+
+import (
+	"bytes"
+	"compress/zlib"
+	"encoding/binary"
+	"hash/crc32"
+	"io"
+)
+
+const cromVersion = 3
+
+// cromMaxTrailer 是载荷允许超出头部 mem_size 的最大余量 (MMU 页表尾部元数据)。
+// 必须与 Python 侧 codecin/crom.py: CROM_MAX_TRAILER 保持一致。
+const cromMaxTrailer = 4 << 20
+
+// CromPack 打包内存镜像为 CROM 字节流 (compress=true 时 zlib 压缩)。
+func CromPack(data []byte, compress bool) []byte {
+	var payload []byte
+	flags := byte(0)
+	if compress {
+		flags = 0x01
+		var buf bytes.Buffer
+		// zlib.NewWriter 使用默认压缩级别 (flate.DefaultCompression = 6)
+		w := zlib.NewWriter(&buf)
+		_, _ = w.Write(data)
+		_ = w.Close()
+		payload = buf.Bytes()
+	} else {
+		payload = data
+	}
+
+	out := make([]byte, 16+len(payload))
+	copy(out[0:4], "CROM")
+	out[4] = cromVersion
+	binary.LittleEndian.PutUint32(out[5:9], uint32(len(data)))
+	out[9] = flags
+	binary.LittleEndian.PutUint32(out[10:14], crc32.ChecksumIEEE(payload))
+	// [14:16] reserved 0
+	copy(out[16:], payload)
+	return out
+}
+
+// CromUnpack 解包 CROM, 返回 (raw, flags, ok)。
+func CromUnpack(data []byte) ([]byte, int, bool) {
+	if len(data) < 16 || string(data[0:4]) != "CROM" {
+		return nil, 0, false
+	}
+	if data[4] != cromVersion {
+		return nil, 0, false
+	}
+	memSize := binary.LittleEndian.Uint32(data[5:9])
+	flags := data[9]
+	checksum := binary.LittleEndian.Uint32(data[10:14])
+	payload := data[16:]
+	if crc32.ChecksumIEEE(payload) != checksum {
+		return nil, 0, false
+	}
+
+	var raw []byte
+	if flags&0x01 != 0 {
+		r, err := zlib.NewReader(bytes.NewReader(payload))
+		if err != nil {
+			return nil, 0, false
+		}
+		// 解压上限取自文件头声明的 mem_size + MMU 尾部余量: 防止 zip bomb
+		// (旧实现 io.ReadAll 无上限, 65KB 的合法 CROM 可解出 64MB+)。
+		limit := int64(memSize) + cromMaxTrailer
+		limited := io.LimitReader(r, limit+1)
+		raw, err = io.ReadAll(limited)
+		_ = r.Close()
+		if err != nil {
+			return nil, 0, false
+		}
+	} else {
+		raw = payload
+	}
+	// mem_size 是物理内存长度; 之后允许跟一段 MMU 页表尾部元数据
+	if uint32(len(raw)) < memSize || len(raw) > int(memSize)+cromMaxTrailer {
+		return nil, 0, false
+	}
+	return raw, int(flags), true
+}

codecin/native/engine/encode.go

@@ -0,0 +1,93 @@
+package engine
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+
+	"codecin-native/ir"
+)
+
+// UCBC 字节码编码 (与 Python codecin/native.py encode_program 严格一致)。
+const (
+	bcMagic   = "UCBC"
+	bcVersion = 1
+)
+
+// condCode: 条件助记符 -> 编号 (与 Python Cond.NAMES 一致)
+var condCode = map[string]uint8{
+	"EQ": 0, "NE": 1, "CS": 2, "CC": 3, "MI": 4, "PL": 5, "VS": 6, "VC": 7,
+	"HI": 8, "LS": 9, "GE": 10, "LT": 11, "GT": 12, "LE": 13, "AL": 14, "NV": 15,
+}
+
+// EncodeProgram 把 IR 程序编码为 UCBC 字节码。
+func EncodeProgram(prog ir.Program, entry int) ([]byte, error) {
+	labels := map[string]int{}
+	for k, v := range prog.Labels {
+		labels[k] = v
+	}
+	for k, v := range prog.DataLabels {
+		labels[k] = v
+	}
+
+	buf := make([]byte, 0, 13+len(prog.Instructions)*8)
+	buf = append(buf, bcMagic...)
+	buf = append(buf, bcVersion)
+	var tmp [8]byte
+	binary.LittleEndian.PutUint32(tmp[:4], uint32(entry&0xFFFFFFFF))
+	buf = append(buf, tmp[:4]...)
+	binary.LittleEndian.PutUint32(tmp[:4], uint32(len(prog.Instructions)&0xFFFFFFFF))
+	buf = append(buf, tmp[:4]...)
+
+	for _, ins := range prog.Instructions {
+		opv, ok := opcodeByName[ins.Op]
+		if !ok {
+			return nil, fmt.Errorf("unknown opcode: %s", ins.Op)
+		}
+		buf = append(buf, opv, byte(len(ins.Args)))
+		for _, a := range ins.Args {
+			kind, value, extra, err := encodeOperand(a, labels)
+			if err != nil {
+				return nil, err
+			}
+			buf = append(buf, kind)
+			binary.LittleEndian.PutUint64(tmp[:8], uint64(value))
+			buf = append(buf, tmp[:8]...)
+			binary.LittleEndian.PutUint64(tmp[:8], uint64(extra))
+			buf = append(buf, tmp[:8]...)
+		}
+	}
+	return buf, nil
+}
+
+func encodeOperand(op ir.Operand, labels map[string]int) (kind uint8, value, extra int64, err error) {
+	switch op.Kind {
+	case "reg":
+		return kindReg, op.V, 0, nil
+	case "imm":
+		return kindImm, op.V, 0, nil
+	case "vec":
+		return kindVec, op.V, 0, nil
+	case "veclane":
+		return kindVecLane, op.V, op.Off, nil
+	case "mem":
+		return kindMem, op.V, op.Off, nil
+	case "cond":
+		c, ok := condCode[op.Name]
+		if !ok {
+			return 0, 0, 0, fmt.Errorf("unknown cond: %s", op.Name)
+		}
+		return kindCond, int64(c), 0, nil
+	case "float":
+		return kindFloat, int64(math.Float64bits(op.F)), 0, nil
+	case "str":
+		return kindStr, op.V, 0, nil
+	case "label":
+		addr, ok := labels[op.Name]
+		if !ok {
+			return 0, 0, 0, fmt.Errorf("undefined label: %s", op.Name)
+		}
+		return kindImm, int64(addr), 0, nil
+	}
+	return 0, 0, 0, fmt.Errorf("unknown operand kind: %s", op.Kind)
+}