use std::collections::dict;

use std::lang::gen;

/// Define a symbol at the current text or data offset.

    let idx = a.symbolsLen;

    let offset: i32 = a.dataLen as i32

        if a.section == super::Section::Data

        else a.textLen as i32 * rv64::INSTR_SIZE;

    set a.symbolsLen += 1;

    dict::insert(&mut a.symbolMap, name, idx as i32);

}

/// Append one encoded instruction word to the text section.

    if a.textLen >= a.text.len {

        throw super::Error::TextOverflow;

    }

    set a.text[a.textLen] = word;

    set a.textLen += 1;

}

/// Append `words` no-op instructions to the text section.

    for _ in 0..words {

        try emitText(a, encode::nop());

    }

}

/// Append one byte to the data section.

    if a.dataLen >= a.data.len {

        throw super::Error::DataOverflow;

    }

    set a.data[a.dataLen] = byte;

    set a.dataLen += 1;

}

/// Emit a little-endian integer with `bytes` bytes.

    for i in 0..bytes {

        try emitByte(a, ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8);

    }

}

        set a.data[offset + i] = ((bits >> ((i as u64) * super::BITS_PER_BYTE)) & super::BYTE_MASK) as u8;

    }

}

/// Emit an integer data directive value.

    match width {

        case super::DataWidth::Word => try emitDataInt(a, value as u64, rv64::WORD_SIZE as u32),

        case super::DataWidth::Dword => try emitDataInt(a, value as u64, rv64::DWORD_SIZE as u32),

    }

}

/// Record a data-section symbol fixup and reserve its bytes.

    let offset = a.dataLen;

    match width {

        case super::DataWidth::Word => {

            recordFixup(a, target, super::FixupInfo::Word { offset });

            try emitDataInt(a, 0, rv64::WORD_SIZE as u32);

        }

    }

}

/// Record a pending symbol fixup.

    assert a.fixupsLen < a.fixups.len, "recordFixup: fixup buffer full";

    set a.fixups[a.fixupsLen] = super::Fixup { symbol, info };

    set a.fixupsLen += 1;

}

/// Record a text fixup that must be resolved after all program text is known.

    assert a.externalFixupsLen < a.externalFixups.len, "recordExternalFixup: fixup buffer full";

    set a.externalFixups[a.externalFixupsLen] = fixup;

    set a.externalFixupsLen += 1;

}

/// Record a text-section symbol fixup and reserve its instruction words.

    recordFixup(a, symbol, info);

    try emitTextPadding(a, words);

}

/// Find a previously defined symbol by name.

    }

    return symbol.offset + (a.dataBase as i32);

}

/// Resolve final symbol references and patch all delayed output.

    for i in 0..a.fixupsLen {

        let fixup = a.fixups[i];

        let symbol = findSymbol(a, fixup.symbol) else {

            match fixup.info {

                case super::FixupInfo::Jal { .. }, super::FixupInfo::Addr { .. } => {

        case super::BranchOp::Bgt  => return encode::bgt(rs1, rs2, imm),

    }

}

/// Decode string literal escapes and emit the resulting data bytes.

    let raw = &literal[super::QUOTE_DELIM_LEN..literal.len - super::QUOTE_DELIM_LEN];

    let mut i: u32 = 0;

    while i < raw.len {

        if raw[i] == '\\' and i + 1 < raw.len {

    }

    return value as i32;

}

/// Define a label at the current text or data offset.

    if dict::get(&a.symbolMap, name) <> nil {

        throw failOnToken(tok, "duplicate label");

    }

    emit::defineSymbol(a, name);

}

/// Emit a parsed integer data value after applying source-level range checks.

    match width {

        case super::DataWidth::Word =>

            try emit::emitDataValue(a, (try expectI32Value(a, value, "word literal out of range")) as i64, width),

        case super::DataWidth::Dword =>

            try emit::emitDataValue(a, value, width),