///|
/// DEX 容器解析内部实现:字节读取、变长编码、MUTF-8、adler32 与六表解析。
/// 全部错误以 `DexError` 传播,禁止 panic;每个错误带 TableKind / 偏移 / 索引上下文。

///|
/// 取单字节(调用方保证 `off` 在界内)。
fn byte_at(data : Bytes, off : Int32) -> Int32 {
  data.at(off).to_int()
}

///|
/// 小端读 u16。
fn read_u16(data : Bytes, off : Int32) -> Int32 {
  byte_at(data, off) | (byte_at(data, off + 1) << 8)
}

///|
/// 小端读 u32,按位模式返回 `Int`(可能为负,用作偏移前须校验)。
fn read_u32(data : Bytes, off : Int32) -> Int32 {
  byte_at(data, off) |
  (byte_at(data, off + 1) << 8) |
  (byte_at(data, off + 2) << 16) |
  (byte_at(data, off + 3) << 24)
}

///|
/// 小端读 u32,返回 `UInt`(checksum / endian_tag / access_flags)。
fn read_u32u(data : Bytes, off : Int32) -> UInt32 {
  (byte_at(data, off).reinterpret_as_uint() & 0xFFU) |
  ((byte_at(data, off + 1).reinterpret_as_uint() & 0xFFU) << 8) |
  ((byte_at(data, off + 2).reinterpret_as_uint() & 0xFFU) << 16) |
  ((byte_at(data, off + 3).reinterpret_as_uint() & 0xFFU) << 24)
}

///|
/// 拷贝 `data[off..off+len]` 为独立 `Bytes`。
fn slice_bytes(data : Bytes, off : Int32, len : Int32) -> Bytes {
  let arr : Array[Byte] = []
  for i in 0.. (Int32, Int32)? {
  let mut result = 0
  let mut shift = 0
  let mut pos = off
  let mut answer : (Int32, Int32)? = None
  let mut failed = false
  while answer is None && !failed {
    if pos >= data.length() {
      failed = true
    } else {
      let b = byte_at(data, pos)
      pos = pos + 1
      if shift == 28 && (b & 0x70) != 0 {
        failed = true
      } else {
        result = result | ((b & 0x7f) << shift)
        if (b & 0x80) == 0 {
          answer = Some((result, pos))
        } else {
          shift = shift + 7
        }
      }
    }
  }
  answer
}

///|
/// 尝试读 sleb128(32 位有符号变长),返回 `Some((值, 下一偏移))`;
/// 截断或超出 32 位返回 `None`。
fn try_sleb128(data : Bytes, off : Int32) -> (Int32, Int32)? {
  let mut result = 0
  let mut shift = 0
  let mut pos = off
  let mut answer : (Int32, Int32)? = None
  let mut failed = false
  while answer is None && !failed {
    if pos >= data.length() {
      failed = true
    } else {
      let b = byte_at(data, pos)
      pos = pos + 1
      if shift == 28 && !((b & 0x78) == 0 || (b & 0x78) == 0x78) {
        failed = true
      } else {
        let contribution = if shift == 28 {
          (b & 0x0f) << 28
        } else {
          (b & 0x7f) << shift
        }
        result = result | contribution
        if (b & 0x80) == 0 {
          if shift < 28 && (b & 0x40) != 0 {
            result = result | (-1 << (shift + 7))
          }
          answer = Some((result, pos))
        } else {
          shift = shift + 7
        }
      }
    }
  }
  answer
}

///|
/// 在 code_item 内读 uleb128;失败抛 `BadCodeItem`。
fn uleb_code(
  data : Bytes,
  off : Int32,
  code_off : Int32,
) -> (Int32, Int32) raise DexError {
  match try_uleb128(data, off) {
    Some(r) => r
    None =>
      raise DexError::BadCodeItem(
        code_off,
        "malformed uleb128 at offset " + off.to_string(),
      )
  }
}

///|
/// 在 debug_info 内读 uleb128;失败抛 `BadDebugInfo`。
fn uleb_debug(
  data : Bytes,
  off : Int32,
  dbg_off : Int32,
) -> (Int32, Int32) raise DexError {
  match try_uleb128(data, off) {
    Some(r) => r
    None =>
      raise DexError::BadDebugInfo(
        dbg_off,
        "malformed uleb128 at offset " + off.to_string(),
      )
  }
}

///|
/// 在 class_data 内读 uleb128;失败抛 `BadTableOffset(ClassDef, ...)`。
fn uleb_data(
  data : Bytes,
  off : Int32,
  data_off : Int32,
) -> (Int32, Int32) raise DexError {
  match try_uleb128(data, off) {
    Some(r) => r
    None => raise DexError::BadTableOffset(TableKind::ClassDef, data_off)
  }
}

///|
/// 在 catch handler 内读 sleb128;失败抛 `BadCodeItem`。
fn sleb_code(
  data : Bytes,
  off : Int32,
  code_off : Int32,
) -> (Int32, Int32) raise DexError {
  match try_sleb128(data, off) {
    Some(r) => r
    None =>
      raise DexError::BadCodeItem(
        code_off,
        "malformed sleb128 at offset " + off.to_string(),
      )
  }
}

///|
/// 解码 MUTF-8 字符串(含 0xC0 0x80 编码的 NUL),返回 `Some((字符串, 终止符后偏移))`。
/// 非法序列或越界返回 `None`。
fn try_mutf8(data : Bytes, off : Int32) -> (String, Int32)? {
  let chars : Array[Char] = []
  let mut pos = off
  let mut answer : (String, Int32)? = None
  let mut failed = false
  while answer is None && !failed {
    if pos >= data.length() {
      failed = true
    } else {
      let b = byte_at(data, pos)
      if b == 0 {
        answer = Some((String::from_array(chars), pos + 1))
      } else if b < 0x80 {
        chars.push(b.unsafe_to_char())
        pos = pos + 1
      } else if (b & 0xe0) == 0xc0 {
        if pos + 1 >= data.length() {
          failed = true
        } else {
          let b2 = byte_at(data, pos + 1)
          if (b2 & 0xc0) != 0x80 {
            failed = true
          } else {
            chars.push((((b & 0x1f) << 6) | (b2 & 0x3f)).unsafe_to_char())
            pos = pos + 2
          }
        }
      } else if (b & 0xf0) == 0xe0 {
        if pos + 2 >= data.length() {
          failed = true
        } else {
          let b2 = byte_at(data, pos + 1)
          let b3 = byte_at(data, pos + 2)
          if (b2 & 0xc0) != 0x80 || (b3 & 0xc0) != 0x80 {
            failed = true
          } else {
            chars.push(
              (((b & 0x0f) << 12) | ((b2 & 0x3f) << 6) | (b3 & 0x3f)).unsafe_to_char(),
            )
            pos = pos + 3
          }
        }
      } else {
        failed = true
      }
    }
  }
  answer
}

///|
/// adler32 校验和(DEX checksum 字段算法),覆盖 `data[start..end]`。
fn adler32(data : Bytes, start : Int32, end : Int32) -> UInt32 {
  let m : UInt32 = 65521U
  let mut a : UInt32 = 1U
  let mut b : UInt32 = 0U
  let mut i = start
  while i < end {
    a = a + data.at(i).to_uint()
    if a >= m {
      a = a - m
    }
    b = b + a
    if b >= m {
      b = b - m
    }
    i = i + 1
  }
  (b << 16) | a
}

///|
/// 无符号十六进制格式化(小写、无前缀,至少 `min_digits` 位)。
fn hex_u(v : UInt32, min_digits : Int32) -> String {
  let digits = "0123456789abcdef"
  let mut s = ""
  let mut x = v
  let mut n = 0
  while x != 0U {
    let d = (x & 15U).to_byte().to_int()
    s = digits[d:d + 1].to_owned() + s
    x = x >> 4
    n = n + 1
  }
  while n < min_digits {
    s = "0" + s
    n = n + 1
  }
  if n == 0 {
    s = "0"
  }
  s
}

///|
/// 32 位有符号整数字面量的 smali 风格格式:`#+0x1` / `#-0x1`。
fn fmt_sint(v : Int32) -> String {
  if v < 0 {
    "#-0x" + hex_u((v.lnot() + 1).reinterpret_as_uint(), 1)
  } else {
    "#+0x" + hex_u(v.reinterpret_as_uint(), 1)
  }
}

///|
/// 64 位字面量(4 个 16 位字,低字在前)的 smali 风格格式。
fn fmt_sint64(words : Array[Int32]) -> String {
  let negative = (words[3] & 0x8000) != 0
  let out : Array[Int32] = []
  if negative {
    let mut carry = 1
    for i in 0..<4 {
      let t = 0xffff - words[i] + carry
      out.push(t & 0xffff)
      carry = t >> 16
    }
  } else {
    for i in 0..<4 {
      out.push(words[i])
    }
  }
  let mut s = ""
  let mut started = false
  let mut i = 3
  while i >= 0 {
    let w = out[i]
    if started {
      s = s + hex_u(w.reinterpret_as_uint(), 4)
    } else if w != 0 {
      s = s + hex_u(w.reinterpret_as_uint(), 1)
      started = true
    }
    i = i - 1
  }
  if !started {
    s = "0"
  }
  if negative {
    "#-0x" + s
  } else {
    "#+0x" + s
  }
}

///|
/// 相对跳转偏移的 smali 风格格式:`+0x5` / `-0x3`。
fn fmt_off(v : Int32) -> String {
  if v < 0 {
    "-0x" + hex_u((v.lnot() + 1).reinterpret_as_uint(), 1)
  } else {
    "+0x" + hex_u(v.reinterpret_as_uint(), 1)
  }
}

///|
/// 字符串数组连接。
fn join_str(arr : Array[String], sep : String) -> String {
  let mut s = ""
  let mut first = true
  for x in arr {
    if first {
      first = false
    } else {
      s = s + sep
    }
    s = s + x
  }
  s
}

///|
/// 寄存器助记:`v0`。
fn fmt_reg(n : Int32) -> String {
  "v" + n.to_string()
}

///|
/// 解析上下文:指令解码阶段需要的已解析表(引用解析用)。
priv struct Ctx {
  strings : Array[String]
  types : Array[String]
  protos : Array[ProtoId]
  fields : Array[FieldDef]
  methods : Array[MethodDef]
  handles : Array[MethodHandleItem]
  call_sites : Array[CallSiteItem]
}

///|
/// 校验一张索引表的偏移与大小;`size == 0` 时不校验。
fn check_table(
  file_size : Int32,
  off : Int32,
  size : Int32,
  item_size : Int32,
  kind : TableKind,
) -> Unit raise DexError {
  if size == 0 {
    return
  }
  if off < 0x70 || off % 4 != 0 || size > (file_size - off) / item_size {
    raise DexError::BadTableOffset(kind, off)
  }
}

///|
/// 读 type_list(u32 size + u16 idx[],4 字节对齐),返回类型索引数组。
fn read_type_list(
  data : Bytes,
  off : Int32,
  types : Array[String],
  kind : TableKind,
) -> Array[Int32] raise DexError {
  let file_size = data.length()
  if off < 0x70 || off % 4 != 0 || off + 4 > file_size {
    raise DexError::BadTableOffset(kind, off)
  }
  let size = read_u32(data, off)
  if size < 0 || size > (file_size - off - 4) / 2 {
    raise DexError::BadTableOffset(kind, off)
  }
  let out : Array[Int32] = []
  for i in 0..= types.length() {
      raise DexError::InvalidIndex(TableKind::TypeId, idx)
    }
    out.push(idx)
  }
  out
}

///|
/// 计算 debug_info 原始字节流长度(到 DBG_END_SEQUENCE 为止)。
fn debug_stream_len(data : Bytes, off : Int32) -> Int32 raise DexError {
  let mut pos = off
  let dbg = off
  let mut done = false
  let mut failed_msg : String? = None
  // prologue: line_start(uleb128p1), parameters_size(uleb128p1), parameter_names
  let (line_start, p1) = uleb_debug(data, pos, dbg)
  ignore(line_start)
  pos = p1
  let (raw_param_size, p2) = uleb_debug(data, pos, dbg)
  // uleb128p1:编码值 = 实际值 + 1
  let param_size = raw_param_size - 1
  pos = p2
  for _ in 0..= data.length() {
      failed_msg = Some("debug_info stream truncated")
    } else {
      let op = byte_at(data, pos)
      pos = pos + 1
      if op == 0x00 {
        done = true
      } else if op == 0x01 {
        let (_, p) = uleb_debug(data, pos, dbg)
        pos = p
      } else if op == 0x02 {
        match try_sleb128(data, pos) {
          Some((_, p)) => pos = p
          None => failed_msg = Some("malformed sleb128")
        }
      } else if op == 0x03 {
        let (_, q1) = uleb_debug(data, pos, dbg)
        let (_, q2) = uleb_debug(data, q1, dbg)
        let (_, q3) = uleb_debug(data, q2, dbg)
        pos = q3
      } else if op == 0x04 {
        let (_, q1) = uleb_debug(data, pos, dbg)
        let (_, q2) = uleb_debug(data, q1, dbg)
        let (_, q3) = uleb_debug(data, q2, dbg)
        let (_, q4) = uleb_debug(data, q3, dbg)
        pos = q4
      } else if op == 0x05 || op == 0x06 {
        let (_, p) = uleb_debug(data, pos, dbg)
        pos = p
      } else if op == 0x07 || op == 0x08 {
        // no operands
      } else if op == 0x09 {
        let (_, p) = uleb_debug(data, pos, dbg)
        pos = p
      } else if op >= 0x0a {
        // special opcode: no operands
      } else {
        failed_msg = Some("unknown debug opcode " + op.to_string())
      }
    }
  }
  match failed_msg {
    Some(msg) => raise DexError::BadDebugInfo(dbg, msg)
    None => pos - off
  }
}

///|
/// 解析 code_item:寄存器、指令流(解码为 `Instruction`)、try/catch 表与 debug_info 原始字节。
fn parse_code_item(
  data : Bytes,
  code_off : Int32,
  ctx : Ctx,
) -> CodeItem raise DexError {
  let file_size = data.length()
  if code_off < 0x70 || code_off + 16 > file_size {
    raise DexError::BadCodeItem(code_off, "code_item header out of bounds")
  }
  let registers_size = read_u16(data, code_off)
  let ins_size = read_u16(data, code_off + 2)
  let outs_size = read_u16(data, code_off + 4)
  let tries_size = read_u16(data, code_off + 6)
  let debug_info_off = read_u32(data, code_off + 8)
  let insns_size = read_u32(data, code_off + 12)
  if insns_size < 0 || insns_size > (file_size - code_off - 16) / 2 {
    raise DexError::BadCodeItem(code_off, "insns_size out of bounds")
  }
  let insns = decode_insns(ctx, code_off, code_off + 16, insns_size, data)
  let mut pos = code_off + 16 + insns_size * 2
  if tries_size > 0 && insns_size % 2 == 1 {
    pos = pos + 2
  }
  let tries : Array[TryItem] = []
  if tries_size > 0 {
    if tries_size > (file_size - pos) / 8 {
      raise DexError::BadCodeItem(code_off, "try_item table out of bounds")
    }
    for i in 0..= file_size {
      raise DexError::BadDebugInfo(
        debug_info_off, "debug_info_off out of bounds",
      )
    }
    let len = debug_stream_len(data, debug_info_off)
    slice_bytes(data, debug_info_off, len)
  }
  CodeItem::{
    registers_size,
    ins_size,
    outs_size,
    tries_size,
    debug_info_off,
    insns,
    tries,
    debug_info,
  }
}

///|
/// 解析 class_data_item,返回 (static_fields, instance_fields, direct_methods, virtual_methods);
/// 同时把 method 的 access_flags / code 回填进 `ctx.methods`。
fn parse_class_data(
  data : Bytes,
  data_off : Int32,
  ctx : Ctx,
) -> (Array[FieldDef], Array[FieldDef], Array[MethodDef], Array[MethodDef]) raise DexError {
  let file_size = data.length()
  if data_off < 0x70 || data_off >= file_size {
    raise DexError::BadTableOffset(TableKind::ClassDef, data_off)
  }
  let mut pos = data_off
  let (static_size, p1) = uleb_data(data, pos, data_off)
  let (instance_size, p2) = uleb_data(data, p1, data_off)
  let (direct_size, p3) = uleb_data(data, p2, data_off)
  let (virtual_size, p4) = uleb_data(data, p3, data_off)
  pos = p4
  let static_fields : Array[FieldDef] = []
  let instance_fields : Array[FieldDef] = []
  let direct_methods : Array[MethodDef] = []
  let virtual_methods : Array[MethodDef] = []
  // encoded_field × (static + instance)
  // DEX 规范:static_fields 与 instance_fields 是两个独立分段,
  // 每段首个条目的 field_idx_diff 即绝对索引(该段从 0 起累加)。
  let mut field_idx = 0
  for i in 0..<(static_size + instance_size) {
    if i == static_size {
      field_idx = 0 // 进入 instance_fields 分段,复位(AOSP libdex 行为)
    }
    let (diff, pa) = uleb_data(data, pos, data_off)
    let (flags, pb) = uleb_data(data, pa, data_off)
    pos = pb
    field_idx = field_idx + diff
    if field_idx < 0 || field_idx >= ctx.fields.length() {
      raise DexError::InvalidIndex(TableKind::FieldId, field_idx)
    }
    let f = ctx.fields[field_idx]
    let fd = FieldDef::{
      class_index: f.class_index,
      type_index: f.type_index,
      name_index: f.name_index,
      access_flags: flags.reinterpret_as_uint(),
    }
    if i < static_size {
      static_fields.push(fd)
    } else {
      instance_fields.push(fd)
    }
    ctx.fields[field_idx] = fd
  }
  // encoded_method × (direct + virtual)
  // DEX 规范:direct_methods 与 virtual_methods 是两个独立分段,
  // 每段首个条目的 method_idx_diff 即绝对索引(该段从 0 起累加)。
  let mut method_idx = 0
  for k in 0..<(direct_size + virtual_size) {
    if k == direct_size {
      method_idx = 0 // 进入 virtual_methods 分段,复位(AOSP libdex 行为)
    }
    let (diff, pa) = uleb_data(data, pos, data_off)
    let (flags, pb) = uleb_data(data, pa, data_off)
    let (code_off, pc) = uleb_data(data, pb, data_off)
    pos = pc
    method_idx = method_idx + diff
    if method_idx < 0 || method_idx >= ctx.methods.length() {
      raise DexError::InvalidIndex(TableKind::MethodId, method_idx)
    }
    let m = ctx.methods[method_idx]
    let code = if code_off == 0 {
      None
    } else {
      Some(parse_code_item(data, code_off, ctx))
    }
    let md = MethodDef::{
      class_index: m.class_index,
      name_index: m.name_index,
      proto_index: m.proto_index,
      access_flags: flags.reinterpret_as_uint(),
      code_off,
      code,
    }
    if k < direct_size {
      direct_methods.push(md)
    } else {
      virtual_methods.push(md)
    }
    ctx.methods[method_idx] = md
  }
  (static_fields, instance_fields, direct_methods, virtual_methods)
}

///|
/// 校验 DEX 头:magic、版本、header_size、endian_tag、size_field 与 checksum,
/// 并检测 ZIP/APK 容器与多 dex 拼接(`MultiDexNotMerged`)。返回版本。
/// `parse_dex` 与注解/静态初值入口共享同一校验序列(行为等价、纯代码搬移)。
fn validate_header(data : Bytes) -> DexVersion raise DexError {
  let file_size = data.length()
  if file_size < 2 {
    raise DexError::UnexpectedEof(file_size)
  }
  // 多 dex / 容器误喂检测
  if byte_at(data, 0) == 0x50 && byte_at(data, 1) == 0x4b {
    raise DexError::MultiDexNotMerged(
      "input is a ZIP/APK container, not a single DEX",
    )
  }
  if file_size < 0x70 {
    raise DexError::UnexpectedEof(file_size)
  }
  // magic "dex\nNNN\0"
  if byte_at(data, 0) != 0x64 ||
    byte_at(data, 1) != 0x65 ||
    byte_at(data, 2) != 0x78 ||
    byte_at(data, 3) != 0x0a {
    raise DexError::BadMagic("not a DEX file (magic mismatch)")
  }
  if byte_at(data, 7) != 0 {
    raise DexError::BadMagic("bad magic terminator")
  }
  let d1 = byte_at(data, 4)
  let d2 = byte_at(data, 5)
  let d3 = byte_at(data, 6)
  if d1 < 0x30 || d1 > 0x39 || d2 < 0x30 || d2 > 0x39 || d3 < 0x30 || d3 > 0x39 {
    raise DexError::BadMagic("bad version digits")
  }
  let ver = (d1 - 0x30) * 100 + (d2 - 0x30) * 10 + (d3 - 0x30)
  let version = match ver {
    35 => DexVersion::Dex035
    37 => DexVersion::Dex037
    38 => DexVersion::Dex038
    39 => DexVersion::Dex039
    40 => DexVersion::Dex040
    41 => DexVersion::Dex041
    _ =>
      raise DexError::UnsupportedVersion(
        "unsupported DEX version " + ver.to_string(),
      )
  }
  let checksum = read_u32u(data, 8)
  let size_field = read_u32(data, 32)
  let header_size = read_u32(data, 36)
  let endian_tag = read_u32u(data, 40)
  if header_size != 0x70 {
    raise DexError::BadMagic("bad header_size " + header_size.to_string())
  }
  if endian_tag != 0x12345678U {
    raise DexError::BadMagic(
      "bad endian_tag (only little-endian 0x12345678 supported)",
    )
  }
  if size_field <= 0 || size_field > file_size {
    raise DexError::UnexpectedEof(file_size)
  }
  if size_field < file_size {
    raise DexError::MultiDexNotMerged(
      "trailing bytes after file_size; concatenated multi-dex?",
    )
  }
  // checksum:adler32 覆盖 signature 之后的全部字节
  let computed = adler32(data, 12, file_size)
  if computed != checksum {
    raise DexError::BadMagic(
      "checksum mismatch: header=" +
      hex_u(checksum, 8) +
      " computed=" +
      hex_u(computed, 8),
    )
  }
  version
}

///|
/// 读五张索引表(string/type/proto/field/method)构建解析上下文。
/// 先执行 `validate_header` 校验头部,再校验六表偏移并解析表内容;
/// 由 `parse_dex` 与注解/静态初值入口共享(后者不解码 class_def / code_item)。
fn read_ctx(data : Bytes) -> Ctx raise DexError {
  ignore(validate_header(data))
  let file_size = data.length()
  // 六表位置
  let string_ids_size = read_u32(data, 56)
  let string_ids_off = read_u32(data, 60)
  let type_ids_size = read_u32(data, 64)
  let type_ids_off = read_u32(data, 68)
  let proto_ids_size = read_u32(data, 72)
  let proto_ids_off = read_u32(data, 76)
  let field_ids_size = read_u32(data, 80)
  let field_ids_off = read_u32(data, 84)
  let method_ids_size = read_u32(data, 88)
  let method_ids_off = read_u32(data, 92)
  let class_defs_size = read_u32(data, 96)
  let class_defs_off = read_u32(data, 100)
  check_table(
    file_size,
    string_ids_off,
    string_ids_size,
    4,
    TableKind::StringId,
  )
  check_table(file_size, type_ids_off, type_ids_size, 4, TableKind::TypeId)
  check_table(file_size, proto_ids_off, proto_ids_size, 12, TableKind::ProtoId)
  check_table(file_size, field_ids_off, field_ids_size, 8, TableKind::FieldId)
  check_table(
    file_size,
    method_ids_off,
    method_ids_size,
    8,
    TableKind::MethodId,
  )
  check_table(
    file_size,
    class_defs_off,
    class_defs_size,
    32,
    TableKind::ClassDef,
  )
  // string_ids → strings
  let strings : Array[String] = []
  for i in 0..= file_size {
      raise DexError::BadTableOffset(TableKind::StringId, s_off)
    }
    match try_uleb128(data, s_off) {
      Some((_, body_off)) =>
        match try_mutf8(data, body_off) {
          Some((s, _)) => strings.push(s)
          None => raise DexError::BadTableOffset(TableKind::StringId, s_off)
        }
      None => raise DexError::BadTableOffset(TableKind::StringId, s_off)
    }
  }
  // type_ids → type_descriptors
  let types : Array[String] = []
  for i in 0..= strings.length() {
      raise DexError::InvalidIndex(TableKind::StringId, idx)
    }
    types.push(strings[idx])
  }
  // proto_ids
  let protos : Array[ProtoId] = []
  for i in 0..= strings.length() {
      raise DexError::InvalidIndex(TableKind::StringId, shorty_idx)
    }
    if return_idx < 0 || return_idx >= types.length() {
      raise DexError::InvalidIndex(TableKind::TypeId, return_idx)
    }
    let parameters = if params_off == 0 {
      ([] : Array[Int32])
    } else {
      read_type_list(data, params_off, types, TableKind::ProtoId)
    }
    let params : Array[String] = []
    for t in parameters {
      params.push(types[t])
    }
    protos.push(ProtoId::{
      shorty: strings[shorty_idx],
      return_type: types[return_idx],
      parameters: params,
    })
  }
  // field_ids
  let fields : Array[FieldDef] = []
  for i in 0..= types.length() {
      raise DexError::InvalidIndex(TableKind::TypeId, class_idx)
    }
    if type_idx < 0 || type_idx >= types.length() {
      raise DexError::InvalidIndex(TableKind::TypeId, type_idx)
    }
    if name_idx < 0 || name_idx >= strings.length() {
      raise DexError::InvalidIndex(TableKind::StringId, name_idx)
    }
    fields.push(FieldDef::{
      class_index: class_idx,
      type_index: type_idx,
      name_index: name_idx,
      access_flags: 0U,
    })
  }
  // method_ids
  let methods : Array[MethodDef] = []
  for i in 0..= types.length() {
      raise DexError::InvalidIndex(TableKind::TypeId, class_idx)
    }
    if proto_idx < 0 || proto_idx >= protos.length() {
      raise DexError::InvalidIndex(TableKind::ProtoId, proto_idx)
    }
    if name_idx < 0 || name_idx >= strings.length() {
      raise DexError::InvalidIndex(TableKind::StringId, name_idx)
    }
    methods.push(MethodDef::{
      class_index: class_idx,
      name_index: name_idx,
      proto_index: proto_idx,
      access_flags: 0U,
      code_off: 0,
      code: None,
    })
  }
  // DEX 038+ 指令组支撑表(map_list type 0x0007 / 0x0008):
  // 先解析 method_handles(call_site 的 encoded_value 引用它),再解析
  // call_site_ids;两阶段构造满足 Ctx 的不可变字段。
  let map_off = read_u32(data, 52)
  // map_off 越界先行 fail-closed(与 parse_dex 的 map_list 校验同口径):
  // 038+ 支撑表在 read_ctx 内解析,必须在读 map 前拦住坏偏移。
  if map_off != 0 && (map_off < 0x70 || map_off + 4 > file_size) {
    raise DexError::UnexpectedEof(map_off)
  }
  let handles = parse_method_handles(
    data,
    map_off,
    fields.length(),
    methods.length(),
  )
  let ctx1 = Ctx::{
    strings,
    types,
    protos,
    fields,
    methods,
    handles,
    call_sites: [],
  }
  let call_sites = parse_call_sites(data, map_off, ctx1)
  Ctx::{ strings, types, protos, fields, methods, handles, call_sites, }
}

///|
/// 解析单个 DEX 字节流(公开接口 `parse` 的实现主体)。
fn parse_dex(data : Bytes) -> DexFile raise DexError {
  let version = validate_header(data)
  let file_size = data.length()
  let checksum = read_u32u(data, 8)
  let signature = slice_bytes(data, 12, 20)
  let size_field = read_u32(data, 32)
  let header_size = read_u32(data, 36)
  let endian_tag = read_u32u(data, 40)
  let map_off = read_u32(data, 52)
  let class_defs_size = read_u32(data, 96)
  let class_defs_off = read_u32(data, 100)
  let ctx = read_ctx(data)
  // class_defs
  let classes : Array[ClassDef] = []
  for i in 0..= ctx.types.length() {
      raise DexError::InvalidIndex(TableKind::TypeId, class_idx)
    }
    let superclass = if superclass_idx == -1 {
      None
    } else {
      if superclass_idx < 0 || superclass_idx >= ctx.types.length() {
        raise DexError::InvalidIndex(TableKind::TypeId, superclass_idx)
      }
      Some(superclass_idx)
    }
    let interfaces = if interfaces_off == 0 {
      ([] : Array[Int32])
    } else {
      read_type_list(data, interfaces_off, ctx.types, TableKind::ClassDef)
    }
    let source_file = if source_file_idx == -1 {
      None
    } else {
      if source_file_idx < 0 || source_file_idx >= ctx.strings.length() {
        raise DexError::InvalidIndex(TableKind::StringId, source_file_idx)
      }
      Some(ctx.strings[source_file_idx])
    }
    let (static_fields, instance_fields, direct_methods, virtual_methods) = if class_data_off ==
      0 {
      (
        ([] : Array[FieldDef]),
        ([] : Array[FieldDef]),
        ([] : Array[MethodDef]),
        ([] : Array[MethodDef]),
      )
    } else {
      parse_class_data(data, class_data_off, ctx)
    }
    classes.push(ClassDef::{
      class_index: class_idx,
      type_descriptor: ctx.types[class_idx],
      superclass_index: superclass,
      interfaces,
      source_file,
      access_flags,
      class_data_off,
      static_fields,
      instance_fields,
      direct_methods,
      virtual_methods,
    })
  }
  // map_list 原始字节
  let map_list = if map_off == 0 {
    Bytes::make(0, b'\x00')
  } else {
    if map_off < 0x70 || map_off + 4 > file_size {
      raise DexError::UnexpectedEof(map_off)
    }
    let count = read_u32(data, map_off)
    if count < 0 || count > (file_size - map_off - 4) / 12 {
      raise DexError::UnexpectedEof(map_off)
    }
    slice_bytes(data, map_off, 4 + count * 12)
  }
  DexFile::{
    version,
    checksum,
    signature,
    file_size: size_field,
    header_size,
    endian_tag,
    strings: ctx.strings,
    type_descriptors: ctx.types,
    protos: ctx.protos,
    fields: ctx.fields,
    methods: ctx.methods,
    classes,
    handles: ctx.handles,
    call_sites: ctx.call_sites,
    map_list,
  }
}