(module                           ;; 模块定义（最外层）
  (func $greet                    ;; 函数定义
    (param $name i32)             ;; 参数
    (result i32)                  ;; 返回值
    local.get $name               ;; 指令
  )
)

;; 两种引用函数的方式：
;; 1. 使用命名（可读性好）
call $my_function

;; 2. 使用数字索引（底层表示）
call 0

i32    ;; 32 位整数
i64    ;; 64 位整数
f32    ;; 32 位浮点数（IEEE 754 单精度）
f64    ;; 64 位浮点数（IEEE 754 双精度）
v128   ;; 128 位 SIMD 向量（需要 SIMD 提案）
funcref ;; 函数引用
externref ;; 外部引用

;; 函数可以返回多个值
(func $divmod (param $a i32) (param $b i32) (result i32 i32)
  local.get $a
  local.get $b
  i32.div_u          ;; 商
  local.get $a
  local.get $b
  i32.rem_u          ;; 余数
)
;; 结果: 返回 [商, 余数] 两个 i32

(module
  ;; 简单的加法函数
  (func $add (param $a i32) (param $b i32) (result i32)
    local.get $a    ;; 将参数 $a 压栈
    local.get $b    ;; 将参数 $b 压栈
    i32.add         ;; 弹出两个值，相加，压入结果
  )
  (export "add" (func $add))
)

(func $example (param $x i32) (param $y i32) (result i32)
  (local $temp i32)       ;; 声明局部变量
  (local $flag i32)       ;; 可以声明多个

  ;; local.set — 赋值
  local.get $x
  local.get $y
  i32.add
  local.set $temp         ;; temp = x + y

  ;; local.tee — 赋值并保持栈上值
  i32.const 42
  local.tee $flag         ;; flag = 42，同时 42 保留在栈上

  drop                    ;; 丢弃栈顶
  local.get $temp         ;; 返回 temp
)

(module
  ;; 定义函数类型
  (type $binop (func (param i32 i32) (result i32)))

  ;; 复用类型定义
  (func $add (type $binop)
    local.get 0
    local.get 1
    i32.add
  )
  (func $mul (type $binop)
    local.get 0
    local.get 1
    i32.mul
  )
)

(block $label
  ;; ... 指令 ...
  (br $label)        ;; 跳出 block
)
;; br $label 跳到这里

;; 循环 10 次
(func $count_to_10
  (local $i i32)
  (local.set $i (i32.const 0))

  (block $break
    (loop $continue
      ;; i++
      local.get $i
      i32.const 1
      i32.add
      local.set $i

      ;; 如果 i < 10，继续循环
      (br_if $break (i32.ge_u (local.get $i) (i32.const 10)))
      (br $continue)
    )
  )
)

(func $abs (param $x i32) (result i32)
  local.get $x
  i32.const 0
  i32.lt_s           ;; x < 0 ?

  (if (result i32)
    (then
      i32.const 0
      local.get $x
      i32.sub         ;; 0 - x = -x
    )
    (else
      local.get $x    ;; 直接返回 x
    )
  )
)

(func $sign (param $x i32) (result i32)
  (if (i32.lt_s (local.get $x) (i32.const 0))
    (then
      (i32.const -1)
    )
    (else
      (if (i32.gt_s (local.get $x) (i32.const 0))
        (then (i32.const 1))
        (else (i32.const 0))
      )
    )
  )
)

(func $switch (param $case i32) (result i32)
  (block $default
    (block $case2
      (block $case1
        (block $case0
          local.get $case
          (br_table $case0 $case1 $case2 $default)
          ;; case 0 → 跳到 $case0
          ;; case 1 → 跳到 $case1
          ;; case 2 → 跳到 $case2
          ;; 其他  → 跳到 $default
        )
        ;; $case0:
        (return (i32.const 100))
      )
      ;; $case1:
      (return (i32.const 200))
    )
    ;; $case2:
    (return (i32.const 300))
  )
  ;; $default:
  (i32.const -1)
)

;; 整数比较（返回 i32，0 = false，1 = true）
i32.eq      ;; 相等
i32.ne      ;; 不等
i32.lt_s    ;; 有符号小于
i32.lt_u    ;; 无符号小于
i32.gt_s    ;; 有符号大于
i32.gt_u    ;; 无符号大于
i32.le_s    ;; 有符号小于等于
i32.ge_s    ;; 有符号大于等于

;; 浮点比较
f64.eq      ;; 相等
f64.ne      ;; 不等
f64.lt      ;; 小于
f64.gt      ;; 大于
f64.le      ;; 小于等于
f64.ge      ;; 大于等于

;; i32 → f64（有符号整数转浮点）
i32.const 42
f64.convert_i32_s    ;; → 42.0

;; f64 → i32（截断浮点为整数）
f64.const 3.14
i32.trunc_f64_s      ;; → 3

;; i32 → i64（扩展）
i32.const -1
i64.extend_i32_s     ;; → -1（符号扩展）
i64.extend_i32_u     ;; → 4294967295（零扩展）

;; i64 → i32（截断）
i64.const 123456789
i32.wrap_i64         ;; → 低 32 位

;; f32 → f64（提升）
f32.const 1.5
f64.promote_f32      ;; → 1.5

;; f64 → f32（截断）
f64.const 1.5
f32.demote_f64       ;; → 1.5

;; 基本加载
i32.load           ;; 从内存加载 i32（4 字节）
i64.load           ;; 从内存加载 i64（8 字节）
f32.load           ;; 从内存加载 f32（4 字节）
f64.load           ;; 从内存加载 f64（8 字节）

;; 窄加载
i32.load8_s        ;; 加载 1 字节，符号扩展为 i32
i32.load8_u        ;; 加载 1 字节，零扩展为 i32
i32.load16_s       ;; 加载 2 字节，符号扩展为 i32
i32.load16_u       ;; 加载 2 字节，零扩展为 i32
i64.load8_s        ;; 加载 1 字节，符号扩展为 i64
i64.load16_s       ;; 等等...
i64.load32_s

;; 带偏移量
i32.load offset=8  ;; 从 (addr + 8) 处加载

;; 带对齐提示
i32.load align=4   ;; 4 字节对齐

;; 基本存储
i32.store          ;; 存储 i32（4 字节）
i64.store          ;; 存储 i64（8 字节）
f32.store          ;; 存储 f32
f64.store          ;; 存储 f64

;; 窄存储（只写低 8/16 位）
i32.store8         ;; 存储低 8 位
i32.store16        ;; 存储低 16 位

;; 带偏移量和对齐
i32.store offset=16 align=2

memory.size        ;; 返回当前内存页数
memory.grow        ;; 增长内存（参数: 要增加的页数，返回: 增长前的页数）
memory.fill        ;; 填充内存区域（类似 memset）
memory.copy        ;; 复制内存区域（类似 memcpy）
memory.init $seg   ;; 从数据段初始化内存
data.drop $seg     ;; 释放数据段

(module
  (memory (export "memory") 1)

  ;; 假设数组起始地址为 0，每个元素 i32（4 字节）
  ;; 数组布局: [count][elem0][elem1][elem2]...
  ;;           0-3    4-7    8-11   12-15

  (func $array_sum (param $ptr i32) (result i32)
    (local $sum i32)     ;; 累加器
    (local $end i32)     ;; 结束地址
    (local $count i32)   ;; 元素数量

    ;; 读取数组长度
    (local.set $count (i32.load (local.get $ptr)))

    ;; 计算结束地址: ptr + 4 + count * 4
    (local.set $end
      (i32.add
        (i32.add (local.get $ptr) (i32.const 4))
        (i32.mul (local.get $count) (i32.const 4))
      )
    )

    ;; 累加器初始化
    (local.set $sum (i32.const 0))

    ;; 遍历数组
    (local.set $ptr (i32.add (local.get $ptr) (i32.const 4)))  ;; 跳过 count
    (block $break
      (loop $loop
        (br_if $break (i32.ge_u (local.get $ptr) (local.get $end)))

        ;; sum += *ptr
        (local.set $sum
          (i32.add (local.get $sum) (i32.load (local.get $ptr)))
        )

        ;; ptr += 4
        (local.set $ptr (i32.add (local.get $ptr) (i32.const 4)))
        (br $loop)
      )
    )
    (local.get $sum)
  )

  (export "arraySum" (func $array_sum))
)

(module
  (memory (export "memory") 1)

  (func $reverse_string (param $start i32) (param $len i32)
    (local $left i32)
    (local $right i32)
    (local $tmp i32)

    (local.set $left (local.get $start))
    (local.set $right
      (i32.sub
        (i32.add (local.get $start) (local.get $len))
        (i32.const 1)
      )
    )

    (block $done
      (loop $swap
        (br_if $done (i32.ge_u (local.get $left) (local.get $right)))

        ;; 交换 left 和 right 处的字节
        (local.set $tmp (i32.load8_u (local.get $left)))
        (i32.store8 (local.get $left) (i32.load8_u (local.get $right)))
        (i32.store8 (local.get $right) (local.get $tmp))

        ;; left++, right--
        (local.set $left (i32.add (local.get $left) (i32.const 1)))
        (local.set $right (i32.sub (local.get $right) (i32.const 1)))
        (br $swap)
      )
    )
  )

  (export "reverseString" (func $reverse_string))
)

;; unreachable — 标记不可达代码，执行时触发 trap
(func $check_positive (param $x i32) (result i32)
  (if (i32.lt_s (local.get $x) (i32.const 0))
    (then (unreachable))  ;; 负数会触发 trap
  )
  (local.get $x)
)

;; nop — 空操作（什么都不做）
nop

;; result = (condition) ? a : b
(if (result i32) (local.get $condition)
  (then (local.get $a))
  (else (local.get $b))
)

;; min(a, b)
(local.get $a)
(local.get $b)
i32.lt_s
(if (result i32) (then (local.get $a)) (else (local.get $b)))

;; 使用内置指令（浮点）
f64.min
f64.max

(local $acc i32)
(local $i i32)
(block $break
  (loop $continue
    ;; ... 使用 $i, 更新 $acc ...
    (local.set $i (i32.add (local.get $i) (i32.const 1)))
    (br_if $break (i32.ge_u (local.get $i) (i32.const N)))
    (br $continue)
  )
)