Method parse_memoryinstr

src/lib/parse/instr_parse.cpp:412–505

// ── Memory instructions ───────────────────────────────────────────────────────

WasmInstr ParseContext::parse_memoryinstr(const std::string& name) {
    if (name == "data.drop") return Instr::Data_drop(parse_dataidx());

    if (name == "memory.copy") {
        index_t dst = 0, src = 0;
        if (tok_.peek().type == TokenType::Integer || tok_.peek().type == TokenType::Id) {
            dst = parse_memidx(); src = parse_memidx();
        }
        return Instr::Memory_copy(dst, src);
    }

    // memory.{size,grow,fill,init}: optional memidx
    if (name.starts_with("memory.")) {
        index_t memidx = 0;
        if (tok_.peek().type == TokenType::Integer || tok_.peek().type == TokenType::Id)
            memidx = parse_memidx();
        if (name == "memory.size") return Instr::Memory_size(memidx);
        if (name == "memory.grow") return Instr::Memory_grow(memidx);
        if (name == "memory.fill") return Instr::Memory_fill(memidx);
        if (name == "memory.init") {
            // memidx? dataidx
            if (tok_.peek().type == TokenType::Integer || tok_.peek().type == TokenType::Id) {
                // had memidx, now get dataidx
                return Instr::Memory_init(memidx, parse_dataidx());
            }
            // only one index: it was dataidx
            return Instr::Memory_init(0, memidx);
        }
    }

    // Load/store: optional memidx then memarg
    index_t memidx = 0;
    if (tok_.peek().type == TokenType::Integer || tok_.peek().type == TokenType::Id) {
        // Could be memidx before offset=, but memidx is only present if followed by another token
        // that is also an index or the next token is offset=/align=
        // Simple heuristic: if the next token is an integer/id and no offset/align follows immediately
        // For now: if tok[0] is integer/id and tok[1] is integer/id/offset/align/RParen/EOF → tok[0] is memidx
        // Actually the WAT spec says memidx is optional and only present in multi-memory proposal.
        // For simplicity: just try to parse memidx if there's an integer/id before offset= or end
        // The tokenizer returns Offset/Align for those, so any integer/id here would be memidx.
        // But we need to be careful — if there's only one integer and it could be the value of
        // i32.const etc. that came before... no, those are not in memoryinstr context.
        // The only integer/id that can appear before offset= in a memory instr is memidx.
        memidx = parse_u32();
        // Check if there's actually more (otherwise treat as... hmm)
        // Actually per grammar: memidx? is only for multi-memory. In practice single-memory
        // modules don't use it. But we should support it.
        // The ambiguity is: if there's ONE integer before offset/align/end, is it memidx or not?
        // In single-memory WAT: no memidx appears. In multi-memory: memidx appears.
        // The grammar says "memidx?" so it's optional. Since an integer here is always memidx
        // (there's nothing else an integer would be), we're fine.
    }
    auto [offset, align] = parse_memarg();

    // Default alignment based on instruction width
    if (!align.has_value()) {
        if (name.ends_with("8") || name.ends_with("8_s") || name.ends_with("8_u"))   align = 0;
        else if (name.ends_with("16") || name.ends_with("16_s") || name.ends_with("16_u")) align = 1;