/// Signed byte offset preceding the base register.

    offset: i32,

}

/// Parse assembler source into the supplied assembler state.

    advance(a);

    while a.scan.current.kind <> scanner::TokenKind::Eof {

        try parseItem(a);

    }

fn isLabel(tok: scanner::TokenKind) -> bool {

    return tok == scanner::TokenKind::Label or tok == scanner::TokenKind::QuotedLabel;

}

/// Parse the contents of a quoted label token, decoding escapes as needed.

    let tok = try expectToken(a, scanner::TokenKind::QuotedLabel, "expected label name");

    let rawStart = super::LABEL_SIGIL_LEN + super::QUOTE_DELIM_LEN;

    let raw = &tok.source[rawStart..tok.source.len - super::QUOTE_DELIM_LEN];

    let len = fmt::unescapeString(raw, storage);

    return strings::intern(a.pool, &storage[..len]);

}

/// Parse a label reference or definition name.

    if a.scan.current.kind == scanner::TokenKind::QuotedLabel {

        return try parseQuotedLabelName(a);

    }

    return try parseScopedName(a, scanner::TokenKind::Label, "expected label name", super::LABEL_SIGIL_LEN);

}

    let name = try expectToken(a, scanner::TokenKind::Directive, "expected directive name");

    return &name.source[super::DIRECTIVE_SIGIL_LEN..];

}

/// Parse one top-level assembler item.

    match a.scan.current.kind {

        case scanner::TokenKind::Ident => {

            let tok = a.scan.current;

            let name = try parseSymbolName(a);

            try parseInstruction(a, name, tok);

    };

    return super::CSRS[index].csr;

}

/// Parse an instruction after its mnemonic has already been consumed.

    if a.section <> super::Section::Text {

        throw failOnToken(tok, "instructions are only valid in the text section");

    }

    if let format = atomics::parse(name) {

        let rd = try parseRegister(a);

    try emit::emitText(a, encode::lui(rd, split.hi));

    try emit::emitText(a, encode::addi(rd, rd, split.lo));

}

/// Parse the `la` pseudo-instruction.

    let rd = try parseRegister(a);

    let target = try parseLabelName(a);

    let index = a.textLen;

    try emit::recordTextFixup(a, target, super::FixupInfo::Addr { rd, index }, 2);

    try emit::emitText(a, enc(rs2, memop.base, memop.offset));

}

/// Parse a two-register branch instruction.

    let rs1 = try parseRegister(a);

    let rs2 = try parseRegister(a);

    try parseBranchLabel(a, op, rs1, rs2);

}

/// Parse an optional label operand.

    if not isLabel(a.scan.current.kind) {

        return nil;

    }

    return try parseLabelName(a);

}

/// Parse a branch target as either a label fixup or immediate offset.

    let index = a.textLen;

    if let target = try parseOptionalLabel(a) {

        try emit::recordTextFixup(a, target, super::FixupInfo::Branch { op, rs1, rs2, index }, 1);

        return;

    }

    let imm = try parseBranchImm(a);

    try emit::emitText(a, emit::encodeBranch(op, rs1, rs2, imm));

}

/// Parse a branch-to-zero pseudo-instruction.

    let rs = try parseRegister(a);

    try parseBranchLabel(a, op, rs, rv64::ZERO);

}

/// Parse `jal` with an explicit destination register.

    let rd = try parseRegister(a);

    try parseJ(a, rd);

}

/// Parse a jump target for `jal` or a jump pseudo-instruction.

    let index = a.textLen;

    if let target = try parseOptionalLabel(a) {

        try emit::recordTextFixup(a, target, super::FixupInfo::Jal { rd, index }, 1);

        return;

    }

    }

    try emit::emitText(a, enc(rd, imm64 as i32));

}

/// Parse a directive after its name has already been consumed.

    let directive = classifyDirective(name) else {

        throw failOnToken(tok, "unknown directive");

    };

    match directive {

        case super::DirectiveKind::Text => {

    dict::insert(&mut a.constMap, name, value);

}

/// Parse a `.export` directive.

    let name = try parseLabelName(a);

    dict::insert(&mut a.exportMap, name, 1);

    if let idx = dict::get(&a.symbolMap, name) {

        set a.symbols[idx as u32].isExported = true;

    }

        }

    }

}

/// Parse a fixed-width integer data directive.

    loop {

        if isLabel(a.scan.current.kind) {

            let target = try parseLabelName(a);

            try emit::recordDataFixup(a, target, width);

        } else if a.scan.current.kind == scanner::TokenKind::Char {