/// Parser and emission state.

export record Assembler {

    /// Allocation arena for temporary assembler state.

    arena: *unsafe mut alloc::Arena,

    /// Assembler lexical scanner.

    scan: scanner::Scanner,

    /// Output text buffer.

    text: *mut [u32],

    /// Number of emitted text words.

    let symbolBuf = symbols as *mut [Symbol];

    let fixupBuf = fixups as *mut [Fixup];

    let externalBuf = externalFixups as *mut [Fixup];

    let mut a = Assembler {

        arena: arena as *unsafe mut alloc::Arena,

        text: textBuf,

        textLen: 0,

        data: dataBuf,

        dataLen: 0,

        section: Section::Text,

        externalFixups: &pendingFixups[..externalFixupsLen],

    };

}

/// Bound symbol and fixup counts by lexical tokens, including one spare slot.

    let mut count = SOURCE_CAP_PADDING;

    while true {

        if token.kind == scanner::TokenKind::Eof {

            break;

        }

        set count += 1;

        if token.kind == scanner::TokenKind::Invalid {

}

/// Advance the parser by one token, preserving the previous token.

unsafe fn advance(a: &mut super::Assembler) {

    set a.scan.previous = a.scan.current;

}

/// Consume the current token when it has `kind`.

unsafe fn consume(a: &mut super::Assembler, kind: scanner::TokenKind) -> bool {

    if a.scan.current.kind == kind {

    while consume(a, scanner::TokenKind::ColonColon) {

        let segment = try expectToken(a, scanner::TokenKind::Ident, "expected identifier after `::`");

        set end = segment.offset + segment.source.len;

    }

    let source = &a.scan.source[start..end];

}

/// Parse a bare symbol name.

unsafe fn parseSymbolName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {

    return try parseScopedName(a, scanner::TokenKind::Ident, "expected symbol name", 0);

    let storage = try alloc::allocSlice(a.arena, 1, 1, raw.len) catch {

        panic "asm: out of memory allocating quoted label";

    } as *mut [u8];

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

}

/// Parse a label reference or definition name.

unsafe fn parseLabelName(a: &mut super::Assembler) -> *[u8] throws (super::Error) {

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

    cursor: u32,

    /// Current token observed by the parser.

    current: Token,

    /// Previously consumed token observed by the parser.

    previous: Token,

}

/// Individual token with kind, source text, and byte offset.

export record Token: Copy {

    /// Token kind.

    /// Byte offset of `source` in the input buffer.

    offset: u32,

}

/// Create a new assembler scanner.

    let invalidToken = invalid(0, "");

    return Scanner {

        sourceKind,

        source,

        token: 0,

        cursor: 0,

        current: invalidToken,

        previous: invalidToken,

    };

}

/// Create an invalid token with the given message.

export fn invalid(offset: u32, message: *[u8]) -> Token {

            else => return,

        }

    }

}

    skipWhitespace(s);

    set s.token = s.cursor;

    if isEof(s) {

        return tok(s, TokenKind::Eof);

    if char::isDigit(ch) {

        return scanNumber(s);

    }

    if char::isAlpha(ch) or ch == '_' {

    }

    match ch {

        case '(' => return tok(s, TokenKind::LParen),

        case ')' => return tok(s, TokenKind::RParen),

            }

            return invalid(s.token, "unexpected `:`");

        }

        case '"' => return scanString(s),

        case '\'' => return scanChar(s),

        case '-' => return scanSignedNumberOrToken(s, TokenKind::Minus),

        case '+' => return scanSignedNumberOrToken(s, TokenKind::Plus),

        case '/' => return tok(s, TokenKind::Slash),

        case '*' => return tok(s, TokenKind::Star),

        else => return invalid(s.token, "unexpected character"),

    }

    return invalid(s.token, "unterminated character");

}

/// Scan an identifier-shaped token of the given kind.

    scanIdentifierBody(s);

    let source = &s.source[s.token..s.cursor];

    return Token {

        kind,

        offset: s.token,

    };

}

/// Scan a sigil-prefixed identifier-shaped token.

    let ch = current(s) else {

        return invalid(s.token, message);

    };

    if not char::isAlpha(ch) and ch <> '_' {

        return invalid(s.token, message);

    scanIdentifierBody(s);

    let source = &s.source[s.token..s.cursor];

    return Token {

        kind,

        offset: s.token,

    };

}

/// Scan an assembler label token, accepting either `@name` or `@"quoted"` syntax.

    let ch = current(s) else {

        return invalid(s.token, "expected label after `@`");

    };

    if ch == '"' {

        advance(s);

        if let token = scanCharsUntil(s, '"', TokenKind::QuotedLabel) {

            return token;

        }

        return invalid(s.token, "unterminated quoted label");

    }

}

use std::mem;

use std::testing;

use std::lang::strings;

/// String pool used by assembler scanner tests.

/// Create a scanner for test input.

fn testScanner(source: *[u8]) -> super::Scanner {

}

/// Scanner recognizes assembler-specific sigils and scoped names.

    let mut s = testScanner(

        ".text %sp @entry name::tail 42"

    );

    try testing::expect(directive.kind == super::TokenKind::Directive);

    try testing::expect(mem::eq(directive.source, ".text"));

    try testing::expect(reg.kind == super::TokenKind::Register);

    try testing::expect(mem::eq(reg.source, "%sp"));

    try testing::expect(label.kind == super::TokenKind::Label);

    try testing::expect(mem::eq(label.source, "@entry"));

}

/// Keyword-shaped text remains plain assembler identifiers.

    let mut s = testScanner(

        "and or not align addi .text @label"

    );

}

/// Quoted labels can spell symbol names that are not identifier-shaped.

    let mut s = testScanner(

        "@\"foo.bar.baz\""

    );

    try testing::expect(label.kind == super::TokenKind::QuotedLabel);

    try testing::expect(mem::eq(label.source, "@\"foo.bar.baz\""));

}

/// Sigil-prefixed tokens require the name to start immediately after the sigil.

    let mut regScan = testScanner("% a0");

    let mut labelScan = testScanner("@ entry");

    let mut directiveScan = testScanner(". text");

}

/// Scanner reaches EOF after trailing whitespace and comments.

    let mut s = testScanner(

        ".text;\n@start\naddi %a0 %zero 42;\nsd %a0 8(%sp);\n// comment\nbeq %a0 %zero @done;\n@done\nret;\n"

    );

    loop {

        if tok.kind == super::TokenKind::Eof {

            try testing::expect(tok.source.len == 0);

            return;

        }

    }

}

/// Signed numbers scan only the numeric formats supported by the assembler scanner.

    let mut s = testScanner(

        "+0x2a -0b10 45.5"

    );

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "+0x2a"));

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "-0"));

    try testing::expect(tok.kind == super::TokenKind::Ident);

    try testing::expect(mem::eq(tok.source, "b10"));

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "45"));

    try testing::expect(tok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(tok.source, "expected directive name after `.`"));

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "5"));

}

/// Unterminated string and character literals report invalid tokens.

    let mut stringScan = testScanner("\"unterminated");

    try testing::expect(stringTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(stringTok.source, "unterminated string"));

    let mut escapedStringScan = testScanner("\"unterminated\\");

    try testing::expect(escapedStringTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(escapedStringTok.source, "unterminated string"));

    let mut charScan = testScanner("'x");

    try testing::expect(charTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(charTok.source, "unterminated character"));

    let mut escapedCharScan = testScanner("'\\");

    try testing::expect(escapedCharTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(escapedCharTok.source, "unterminated character"));

}