@jhlagado/azm 0.1.0

package/dist/src/frontend/parseImm.js

@@ -0,0 +1,397 @@
+import { parseDiag as diag } from './parseDiagnostics.js';
+import { CHAR_ESCAPE_VALUES, IMM_BINARY_OPERATORS, IMM_BINARY_OPERATOR_PRECEDENCE, IMM_MULTI_CHAR_OPERATORS, IMM_UNARY_OPERATOR_SET, } from './grammarData.js';
+export function immLiteral(filePath, s, value) {
+    return { kind: 'ImmLiteral', span: { ...s, file: filePath }, value };
+}
+function immName(filePath, s, name) {
+    return { kind: 'ImmName', span: { ...s, file: filePath }, name };
+}
+export function parseTypeExprFromText(typeText, typeSpan) {
+    let rest = typeText.trim();
+    const nameMatch = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(rest);
+    if (!nameMatch)
+        return undefined;
+    const name = nameMatch[1];
+    rest = rest.slice(name.length).trimStart();
+    let typeExpr = { kind: 'TypeName', span: typeSpan, name };
+    while (rest.startsWith('[')) {
+        const m = /^\[\s*([0-9]+)?\s*\]/.exec(rest);
+        if (!m)
+            return undefined;
+        const lenText = m[1];
+        if (lenText === undefined)
+            return undefined;
+        typeExpr = {
+            kind: 'ArrayType',
+            span: typeSpan,
+            element: typeExpr,
+            length: Number.parseInt(lenText, 10),
+        };
+        rest = rest.slice(m[0].length).trimStart();
+    }
+    if (rest.length > 0)
+        return undefined;
+    return typeExpr;
+}
+export function diagIfArrayLengthMissing(diagnostics, filePath, typeText, where) {
+    if (!/\[\s*\]/.test(typeText))
+        return false;
+    diag(diagnostics, filePath, `Array length is required here; write T[N].`, where);
+    return true;
+}
+export function parseNumberLiteral(text) {
+    const t = text.trim();
+    if (/^[0-9][0-9A-Fa-f]*[Hh]$/.test(t)) {
+        return Number.parseInt(t.slice(0, -1), 16);
+    }
+    if (/^[01]+[Bb]$/.test(t)) {
+        return Number.parseInt(t.slice(0, -1), 2);
+    }
+    if (/^\$[0-9A-Fa-f]+$/.test(t)) {
+        return Number.parseInt(t.slice(1), 16);
+    }
+    if (/^%[01]+$/.test(t)) {
+        return Number.parseInt(t.slice(1), 2);
+    }
+    if (/^0b[01]+$/.test(t)) {
+        return Number.parseInt(t.slice(2), 2);
+    }
+    if (/^0x[0-9A-Fa-f]+$/i.test(t)) {
+        return Number.parseInt(t.slice(2), 16);
+    }
+    if (/^[0-9]+$/.test(t)) {
+        return Number.parseInt(t, 10);
+    }
+    return undefined;
+}
+function isImmUnaryOp(op) {
+    return IMM_UNARY_OPERATOR_SET.has(op);
+}
+function isImmBinaryOp(op) {
+    return IMM_BINARY_OPERATORS.has(op);
+}
+function isImmOpToken(text) {
+    return IMM_UNARY_OPERATOR_SET.has(text) || IMM_BINARY_OPERATORS.has(text);
+}
+function scanQuotedByteValue(s, start, quote) {
+    let i = start + 1;
+    if (i >= s.length)
+        return undefined;
+    let value;
+    if (s[i] === '\\') {
+        i++;
+        if (i >= s.length)
+            return undefined;
+        const esc = s[i];
+        i++;
+        if (esc === 'x') {
+            const hex = s.slice(i, i + 2);
+            if (!/^[0-9A-Fa-f]{2}$/.test(hex))
+                return undefined;
+            value = Number.parseInt(hex, 16);
+            i += 2;
+        }
+        else {
+            const escaped = CHAR_ESCAPE_VALUES.get(esc);
+            if (escaped === undefined)
+                return undefined;
+            value = escaped;
+        }
+    }
+    else {
+        if (s[i] === quote || s[i] === '\n' || s[i] === '\r')
+            return undefined;
+        const cp = s.codePointAt(i);
+        if (cp === undefined)
+            return undefined;
+        value = cp;
+        i += cp > 0xffff ? 2 : 1;
+    }
+    if (i >= s.length || s[i] !== quote)
+        return undefined;
+    return { value, end: i + 1 };
+}
+function tokenizeImm(text) {
+    const out = [];
+    let i = 0;
+    const s = text.trim();
+    while (i < s.length) {
+        const ch = s[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (ch === '(') {
+            out.push({ kind: 'lparen' });
+            i++;
+            continue;
+        }
+        if (ch === ',') {
+            out.push({ kind: 'comma' });
+            i++;
+            continue;
+        }
+        if (ch === '.') {
+            out.push({ kind: 'dot' });
+            i++;
+            continue;
+        }
+        if (ch === ')') {
+            out.push({ kind: 'rparen' });
+            i++;
+            continue;
+        }
+        if (ch === '[') {
+            out.push({ kind: 'lbrack' });
+            i++;
+            continue;
+        }
+        if (ch === ']') {
+            out.push({ kind: 'rbrack' });
+            i++;
+            continue;
+        }
+        const two = s.slice(i, i + 2);
+        if (IMM_MULTI_CHAR_OPERATORS.has(two)) {
+            out.push({ kind: 'op', text: two });
+            i += 2;
+            continue;
+        }
+        if (ch === '$') {
+            if (/^[0-9A-Fa-f]/.test(s[i + 1] ?? '')) {
+                const num = /^\$[0-9A-Fa-f]+/.exec(s.slice(i));
+                if (!num)
+                    return undefined;
+                out.push({ kind: 'num', text: num[0] });
+                i += num[0].length;
+                continue;
+            }
+            if (/^[A-Za-z_]/.test(s[i + 1] ?? ''))
+                return undefined;
+            out.push({ kind: 'current' });
+            i++;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            const quoted = scanQuotedByteValue(s, i, ch);
+            if (!quoted)
+                return undefined;
+            i = quoted.end;
+            out.push({ kind: 'num', text: String(quoted.value) });
+            continue;
+        }
+        const num = /^([0-9][0-9A-Fa-f]*[Hh]|%[01]+|0b[01]+|0x[0-9A-Fa-f]+|[01]+[Bb]|[0-9]+)/i.exec(s.slice(i));
+        if (num) {
+            out.push({ kind: 'num', text: num[0] });
+            i += num[0].length;
+            continue;
+        }
+        if (isImmOpToken(ch)) {
+            out.push({ kind: 'op', text: ch });
+            i++;
+            continue;
+        }
+        const ident = /^[A-Za-z_][A-Za-z0-9_]*/.exec(s.slice(i));
+        if (ident) {
+            out.push({ kind: 'ident', text: ident[0] });
+            i += ident[0].length;
+            continue;
+        }
+        return undefined;
+    }
+    return out;
+}
+export function parseImmExprFromText(filePath, exprText, exprSpan, diagnostics, emitDiagnostics = true) {
+    const tokenized = tokenizeImm(exprText);
+    if (!tokenized) {
+        if (emitDiagnostics) {
+            diag(diagnostics, filePath, `Invalid imm expression: ${exprText}`, {
+                line: exprSpan.start.line,
+                column: exprSpan.start.column,
+            });
+        }
+        return undefined;
+    }
+    const tokens = tokenized;
+    let idx = 0;
+    function parseDottedIdentName() {
+        const first = tokens[idx];
+        if (!first || first.kind !== 'ident')
+            return undefined;
+        const parts = [first.text];
+        idx++;
+        while (tokens[idx]?.kind === 'dot') {
+            const next = tokens[idx + 1];
+            if (!next || next.kind !== 'ident')
+                return undefined;
+            parts.push(next.text);
+            idx += 2;
+        }
+        return parts.join('.');
+    }
+    function parseBuiltinTypeExprArg() {
+        const nameTok = tokens[idx];
+        if (!nameTok || nameTok.kind !== 'ident')
+            return undefined;
+        const name = nameTok.text;
+        idx++;
+        let typeExpr = { kind: 'TypeName', span: exprSpan, name };
+        while (tokens[idx]?.kind === 'lbrack') {
+            idx++;
+            const lenTok = tokens[idx];
+            if (!lenTok || lenTok.kind !== 'num')
+                return undefined;
+            if (!/^[0-9]+$/.test(lenTok.text))
+                return undefined;
+            const len = Number.parseInt(lenTok.text, 10);
+            idx++;
+            if (tokens[idx]?.kind !== 'rbrack')
+                return undefined;
+            idx++;
+            typeExpr = { kind: 'ArrayType', span: exprSpan, element: typeExpr, length: len };
+        }
+        return typeExpr;
+    }
+    function parseOffsetPathArg() {
+        const root = tokens[idx];
+        if (!root || (root.kind !== 'ident' && root.kind !== 'lbrack'))
+            return undefined;
+        const base = root.kind === 'ident' ? root.text : undefined;
+        if (base !== undefined)
+            idx++;
+        const path = {
+            kind: 'OffsetPath',
+            span: exprSpan,
+            ...(base !== undefined ? { base } : {}),
+            steps: [],
+        };
+        while (true) {
+            if (tokens[idx]?.kind === 'dot') {
+                idx++;
+                const fieldTok = tokens[idx];
+                if (!fieldTok || fieldTok.kind !== 'ident')
+                    return undefined;
+                idx++;
+                path.steps.push({ kind: 'OffsetField', span: exprSpan, name: fieldTok.text });
+                continue;
+            }
+            if (tokens[idx]?.kind === 'lbrack') {
+                idx++;
+                const inner = parseExpr(1);
+                if (!inner)
+                    return undefined;
+                if (tokens[idx]?.kind !== 'rbrack')
+                    return undefined;
+                idx++;
+                path.steps.push({ kind: 'OffsetIndex', span: exprSpan, expr: inner });
+                continue;
+            }
+            break;
+        }
+        return path;
+    }
+    function parseExpr(minPrec) {
+        let left = parsePrimary();
+        if (!left)
+            return undefined;
+        while (true) {
+            const t = tokens[idx];
+            if (!t || t.kind !== 'op')
+                break;
+            const prec = IMM_BINARY_OPERATOR_PRECEDENCE.get(t.text) ?? 0;
+            if (prec < minPrec)
+                break;
+            if (!isImmBinaryOp(t.text))
+                break;
+            idx++;
+            const right = parseExpr(prec + 1);
+            if (!right)
+                return undefined;
+            left = { kind: 'ImmBinary', span: exprSpan, op: t.text, left, right };
+        }
+        return left;
+    }
+    function parsePrimary() {
+        const t = tokens[idx];
+        if (!t)
+            return undefined;
+        if (t.kind === 'num') {
+            idx++;
+            const n = parseNumberLiteral(t.text);
+            if (n === undefined)
+                return undefined;
+            return immLiteral(filePath, exprSpan, n);
+        }
+        if (t.kind === 'current') {
+            idx++;
+            return { kind: 'ImmCurrentLocation', span: { ...exprSpan, file: filePath } };
+        }
+        if (t.kind === 'ident') {
+            if (t.text === 'sizeof' && tokens[idx + 1]?.kind === 'lparen') {
+                idx += 2;
+                const typeExpr = parseBuiltinTypeExprArg();
+                if (!typeExpr)
+                    return undefined;
+                if (tokens[idx]?.kind !== 'rparen')
+                    return undefined;
+                idx++;
+                return { kind: 'ImmSizeof', span: exprSpan, typeExpr };
+            }
+            if (t.text === 'offset' && tokens[idx + 1]?.kind === 'lparen') {
+                idx += 2;
+                const typeExpr = parseBuiltinTypeExprArg();
+                if (!typeExpr)
+                    return undefined;
+                if (tokens[idx]?.kind !== 'comma')
+                    return undefined;
+                idx++;
+                const path = parseOffsetPathArg();
+                if (!path)
+                    return undefined;
+                if (tokens[idx]?.kind !== 'rparen')
+                    return undefined;
+                idx++;
+                return { kind: 'ImmOffset', span: exprSpan, typeExpr, path };
+            }
+            const name = parseDottedIdentName();
+            return name ? immName(filePath, exprSpan, name) : undefined;
+        }
+        if (t.kind === 'dot') {
+            const next = tokens[idx + 1];
+            if (!next || next.kind !== 'ident')
+                return undefined;
+            const name = next.text;
+            idx += 2;
+            return immName(filePath, exprSpan, `.${name}`);
+        }
+        if (t.kind === 'op' && isImmUnaryOp(t.text)) {
+            idx++;
+            const inner = parsePrimary();
+            if (!inner)
+                return undefined;
+            return { kind: 'ImmUnary', span: exprSpan, op: t.text, expr: inner };
+        }
+        if (t.kind === 'lparen') {
+            idx++;
+            const inner = parseExpr(1);
+            if (!inner)
+                return undefined;
+            if (tokens[idx]?.kind !== 'rparen')
+                return undefined;
+            idx++;
+            return inner;
+        }
+        return undefined;
+    }
+    const root = parseExpr(1);
+    if (!root || idx !== tokens.length) {
+        if (emitDiagnostics) {
+            diag(diagnostics, filePath, `Invalid imm expression: ${exprText}`, {
+                line: exprSpan.start.line,
+                column: exprSpan.start.column,
+            });
+        }
+        return undefined;
+    }
+    return root;
+}

package/dist/src/frontend/parseLogicalLines.d.ts

@@ -0,0 +1,11 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { SourceFile } from './source.js';
+export type LogicalLine = {
+    raw: string;
+    startOffset: number;
+    endOffset: number;
+    lineNo: number;
+    filePath: string;
+};
+export declare function buildLogicalLines(file: SourceFile, sourcePath: string, diagnostics: Diagnostic[]): LogicalLine[];
+export declare function getLogicalLine(logicalLines: LogicalLine[], lineIndex: number, sourcePath: string): LogicalLine;

package/dist/src/frontend/parseLogicalLines.js

@@ -0,0 +1,94 @@
+import { parseDiag as diag } from './parseDiagnostics.js';
+export function buildLogicalLines(file, sourcePath, diagnostics) {
+    const logicalLines = [];
+    for (let i = 0; i < file.lineStarts.length; i++) {
+        const startOffset = file.lineStarts[i] ?? 0;
+        const nextStart = file.lineStarts[i + 1] ?? file.text.length;
+        let rawWithEol = file.text.slice(startOffset, nextStart);
+        if (rawWithEol.endsWith('\n'))
+            rawWithEol = rawWithEol.slice(0, -1);
+        if (rawWithEol.endsWith('\r'))
+            rawWithEol = rawWithEol.slice(0, -1);
+        const raw = rawWithEol;
+        const lineNo = file.lineBaseLines?.[i] ?? i + 1;
+        const filePath = file.lineFiles?.[i] ?? sourcePath;
+        let segmentStart = 0;
+        let inChar = false;
+        let inString = false;
+        let escaped = false;
+        for (let j = 0; j < raw.length; j++) {
+            const ch = raw[j];
+            if (inChar || inString) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (ch === '\\') {
+                    escaped = true;
+                    continue;
+                }
+                if (inChar && ch === "'") {
+                    inChar = false;
+                    continue;
+                }
+                if (inString && ch === '"') {
+                    inString = false;
+                    continue;
+                }
+                continue;
+            }
+            if (ch === ';') {
+                break;
+            }
+            if (ch === "'") {
+                inChar = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+                continue;
+            }
+            if (ch === '\\') {
+                const rest = raw.slice(j + 1);
+                const hasWhitespace = rest.length > 0 && /[ \t]/.test(rest[0]);
+                if (!hasWhitespace && rest.length > 0)
+                    continue;
+                const nonSpaceIndex = rest.search(/[^\s]/);
+                const nextToken = nonSpaceIndex >= 0 ? rest[nonSpaceIndex] : '';
+                if (nonSpaceIndex === -1 || nextToken === ';') {
+                    diag(diagnostics, filePath, 'Trailing backslash must be followed by another statement.', {
+                        line: lineNo,
+                        column: j + 1,
+                    });
+                    continue;
+                }
+                const segment = raw.slice(segmentStart, j);
+                logicalLines.push({
+                    raw: segment,
+                    startOffset: startOffset + segmentStart,
+                    endOffset: startOffset + j,
+                    lineNo,
+                    filePath,
+                });
+                segmentStart = j + 1;
+            }
+        }
+        logicalLines.push({
+            raw: raw.slice(segmentStart),
+            startOffset: startOffset + segmentStart,
+            endOffset: startOffset + raw.length,
+            lineNo,
+            filePath,
+        });
+    }
+    return logicalLines;
+}
+export function getLogicalLine(logicalLines, lineIndex, sourcePath) {
+    return (logicalLines[lineIndex] ?? {
+        raw: '',
+        startOffset: 0,
+        endOffset: 0,
+        lineNo: 1,
+        filePath: sourcePath,
+    });
+}

package/dist/src/frontend/parseOp.d.ts

@@ -0,0 +1,25 @@
+import type { OpDeclNode, OpParamNode, SourceSpan } from './ast.js';
+import type { SourceFile } from './source.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { ParseParamsContext } from './parseParams.js';
+type RawLine = {
+    raw: string;
+    startOffset: number;
+    endOffset: number;
+    lineNo: number;
+    filePath: string;
+};
+type ParseOpContext = {
+    file: SourceFile;
+    lineCount: number;
+    diagnostics: Diagnostic[];
+    sourcePath: string;
+    getRawLine: (lineIndex: number) => RawLine;
+    parseOpParamsFromText: (filePath: string, paramsText: string, paramsSpan: SourceSpan, diagnostics: Diagnostic[], ctx: ParseParamsContext) => OpParamNode[] | undefined;
+} & ParseParamsContext;
+type ParsedOpDecl = {
+    node: OpDeclNode;
+    nextIndex: number;
+};
+export declare function parseTopLevelOpDecl(opTail: string, stmtText: string, stmtSpan: SourceSpan, lineNo: number, startIndex: number, ctx: ParseOpContext): ParsedOpDecl | undefined;
+export {};

package/dist/src/frontend/parseOp.js

@@ -0,0 +1,120 @@
+import { span } from './source.js';
+import { parseDiag as diag } from './parseDiagnostics.js';
+import { appendParsedAsmStatement, parseAsmStatement } from './parseAsmStatements.js';
+import { topLevelStartKeyword } from './parseTopLevelCommon.js';
+import { stripLineComment as stripComment } from './parseParserShared.js';
+import { parseOpHeader } from './parseOpHeader.js';
+export function parseTopLevelOpDecl(opTail, stmtText, stmtSpan, lineNo, startIndex, ctx) {
+    const { file, lineCount, diagnostics, sourcePath, getRawLine, isReservedTopLevelName, parseOpParamsFromText, } = ctx;
+    const parsedHeader = parseOpHeader({
+        header: opTail,
+        stmtText,
+        stmtSpan,
+        lineNo,
+        diagnostics,
+        sourcePath,
+        expectedHeader: '<name>(...)',
+        isReservedTopLevelName,
+        parseParams: (paramsText) => parseOpParamsFromText(sourcePath, paramsText, stmtSpan, diagnostics, {
+            isReservedTopLevelName,
+        }),
+    });
+    if (!parsedHeader) {
+        return undefined;
+    }
+    const name = parsedHeader.name;
+    const params = parsedHeader.params;
+    const trailing = parsedHeader.trailing.trim();
+    if (trailing.length > 0) {
+        diag(diagnostics, sourcePath, `Invalid op header: unexpected trailing tokens`, {
+            line: lineNo,
+            column: 1,
+        });
+        return undefined;
+    }
+    const opStartOffset = stmtSpan.start.offset;
+    let index = startIndex + 1;
+    const bodyItems = [];
+    let terminated = false;
+    let interruptedByKeyword;
+    let interruptedByLine;
+    let interruptedByFilePath;
+    let opEndOffset = file.text.length;
+    while (index < lineCount) {
+        const { raw: rawLine, startOffset: so, endOffset: eo, lineNo: bodyLineNo, filePath: bodyFilePath, } = getRawLine(index);
+        const rawNoComment = stripComment(rawLine);
+        const content = rawNoComment.trim();
+        const contentLower = content.toLowerCase();
+        if (content.length === 0) {
+            index++;
+            continue;
+        }
+        if (bodyItems.length === 0 && contentLower === 'asm') {
+            diag(diagnostics, bodyFilePath, `Unexpected "asm" in op body (op bodies are implicit)`, {
+                line: bodyLineNo,
+                column: 1,
+            });
+            index++;
+            continue;
+        }
+        if (contentLower === 'end') {
+            terminated = true;
+            opEndOffset = eo;
+            index++;
+            break;
+        }
+        const topKeyword = topLevelStartKeyword(content);
+        if (topKeyword !== undefined) {
+            interruptedByKeyword = topKeyword;
+            interruptedByLine = bodyLineNo;
+            interruptedByFilePath = bodyFilePath;
+            break;
+        }
+        const fullSpan = span(file, so, eo);
+        const contentStart = rawNoComment.indexOf(content);
+        const contentSpan = contentStart >= 0 ? span(file, so + contentStart, so + rawNoComment.length) : fullSpan;
+        const labelMatch = /^([A-Za-z_][A-Za-z0-9_]*)\s*:(?!\=)\s*(.*)$/.exec(content);
+        if (labelMatch) {
+            const label = labelMatch[1];
+            const remainder = labelMatch[2] ?? '';
+            bodyItems.push({ kind: 'AsmLabel', span: fullSpan, name: label });
+            if (remainder.trim().length > 0) {
+                const stmt = parseAsmStatement(bodyFilePath, remainder, contentSpan, diagnostics);
+                appendParsedAsmStatement(bodyItems, stmt);
+            }
+            index++;
+            continue;
+        }
+        const stmt = parseAsmStatement(bodyFilePath, content, contentSpan, diagnostics);
+        appendParsedAsmStatement(bodyItems, stmt);
+        index++;
+    }
+    if (!terminated) {
+        if (interruptedByKeyword !== undefined && interruptedByLine !== undefined) {
+            diag(diagnostics, interruptedByFilePath ?? sourcePath, `Unterminated op "${name}": expected "end" before "${interruptedByKeyword}"`, {
+                line: interruptedByLine,
+                column: 1,
+            });
+        }
+        else {
+            diag(diagnostics, sourcePath, `Unterminated op "${name}": missing "end"`, {
+                line: lineNo,
+                column: 1,
+            });
+        }
+    }
+    return {
+        node: {
+            kind: 'OpDecl',
+            span: span(file, opStartOffset, opEndOffset),
+            name,
+            params,
+            body: {
+                kind: 'AsmBlock',
+                span: span(file, opStartOffset, opEndOffset),
+                items: bodyItems,
+            },
+        },
+        nextIndex: index,
+    };
+}

package/dist/src/frontend/parseOpHeader.d.ts

@@ -0,0 +1,20 @@
+import type { SourceSpan } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+type ParsedOpHeader<TParam> = {
+    name: string;
+    params: TParam[];
+    trailing: string;
+};
+type ParseOpHeaderOptions<TParam> = {
+    header: string;
+    stmtText: string;
+    stmtSpan: SourceSpan;
+    lineNo: number;
+    diagnostics: Diagnostic[];
+    sourcePath: string;
+    expectedHeader: string;
+    isReservedTopLevelName: (name: string) => boolean;
+    parseParams: (paramsText: string) => TParam[] | undefined;
+};
+export declare function parseOpHeader<TParam>(options: ParseOpHeaderOptions<TParam>): ParsedOpHeader<TParam> | undefined;
+export {};