@jhlagado/azm 0.1.1 → 0.2.0

package/dist/src/core/compile.js

@@ -0,0 +1,164 @@
+import { assembleProgram } from '../assembly/assemble-program.js';
+import { writeIntelHex } from '../outputs/hex.js';
+import { createSourceFile } from '../source/source-file.js';
+import { scanLogicalLines } from '../source/logical-lines.js';
+import { stripLineComment } from '../source/strip-line-comment.js';
+import { parseLogicalLine } from '../syntax/parse-line.js';
+import { parseTypeExpr } from '../syntax/parse-expression.js';
+import { collectOps, expandOpInvocation, parseOpInvocation } from '../expansion/op-expansion.js';
+export function parseNextSourceItems(lines, options = {}) {
+    const diagnostics = [];
+    const items = [];
+    const pendingLines = [...lines];
+    const parseOptions = options.directiveAliasPolicy === undefined
+        ? {}
+        : { directiveAliasPolicy: options.directiveAliasPolicy };
+    const { ops, opLineIndexes } = collectOps(pendingLines, diagnostics, parseOptions);
+    let afterTopLevelEnd = false;
+    for (let index = 0; index < pendingLines.length; index += 1) {
+        if (opLineIndexes.has(index)) {
+            continue;
+        }
+        const line = pendingLines[index];
+        if (afterTopLevelEnd && !isPostEndParseAllowed(line.text)) {
+            continue;
+        }
+        const layoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/i.exec(stripLineComment(line.text).trim());
+        if (layoutHeader) {
+            const layoutKind = (layoutHeader[1] ?? '').toLowerCase() === 'union' ? 'union' : 'record';
+            const endDirective = layoutKind === 'union' ? '.endunion' : '.endtype';
+            const fields = [];
+            let terminated = false;
+            for (index += 1; index < pendingLines.length; index += 1) {
+                const fieldLine = pendingLines[index];
+                const fieldText = stripLineComment(fieldLine.text).trim();
+                if (fieldText.length === 0) {
+                    continue;
+                }
+                if (fieldText.toLowerCase() === endDirective) {
+                    terminated = true;
+                    break;
+                }
+                const field = parseLayoutField(fieldText);
+                if (!field) {
+                    diagnostics.push(parseDiagnostic(fieldLine, `invalid .${layoutHeader[1]} field declaration`));
+                    continue;
+                }
+                fields.push(field);
+            }
+            if (!terminated) {
+                diagnostics.push(parseDiagnostic(line, `.${layoutHeader[1] ?? ''} ${layoutHeader[2] ?? ''} missing ${endDirective}`));
+            }
+            items.push({
+                kind: 'type',
+                name: layoutHeader[2] ?? '',
+                layoutKind,
+                fields,
+                span: { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) },
+            });
+            continue;
+        }
+        const opCall = parseOpInvocation(line);
+        if (opCall && !isTopLevelEnd(line.text)) {
+            const overloads = ops.get(opCall.name);
+            if (overloads) {
+                const expanded = expandOpInvocation(ops, overloads, opCall.operands, line, diagnostics);
+                if (expanded) {
+                    items.push(...expanded);
+                }
+                continue;
+            }
+        }
+        const result = parseLogicalLine(line, parseOptions);
+        diagnostics.push(...result.diagnostics);
+        items.push(...result.items);
+        if (result.items.some((item) => item.kind === 'end')) {
+            afterTopLevelEnd = true;
+        }
+    }
+    return { diagnostics, items };
+}
+export function compileSource(sourceText, options = {}) {
+    const source = createSourceFile(options.entryName ?? '<memory>', sourceText);
+    const { diagnostics, items } = parseNextSourceItems(scanLogicalLines(source));
+    if (diagnostics.length > 0) {
+        return {
+            diagnostics,
+            symbols: {},
+            bytes: new Uint8Array(),
+            hexText: writeIntelHex(0, new Uint8Array()),
+        };
+    }
+    const assembly = assembleProgram(items);
+    const allDiagnostics = [...diagnostics, ...assembly.diagnostics];
+    return {
+        diagnostics: allDiagnostics,
+        symbols: assembly.symbols,
+        bytes: assembly.bytes,
+        hexText: writeIntelHex(assembly.origin, assembly.bytes, assembly.reservedAddresses, assembly.initializedAddresses),
+    };
+}
+/** @deprecated Use {@link compileSource}. */
+export const compileNext = compileSource;
+function isTopLevelEnd(text) {
+    return /^(?:\.end|end)\s*$/i.test(stripLineComment(text).trim());
+}
+function isPostEndParseAllowed(text) {
+    return /^(?:\.binfrom|\.binto|binfrom|binto)\b/i.test(stripLineComment(text).trim());
+}
+function parseLayoutField(text) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/i.exec(text);
+    if (!match) {
+        return undefined;
+    }
+    const name = match[1] ?? '';
+    const directive = (match[2] ?? '').toLowerCase();
+    const operand = match[3]?.trim();
+    switch (directive) {
+        case '.byte':
+            return operand === undefined ? { name, size: 1 } : undefined;
+        case '.word':
+        case '.addr':
+            return operand === undefined ? { name, size: 2 } : undefined;
+        case '.field': {
+            if (operand === undefined) {
+                return undefined;
+            }
+            const size = /^[0-9]+$/.test(operand) ? Number.parseInt(operand, 10) : undefined;
+            if (size !== undefined) {
+                return size > 0 ? { name, size } : undefined;
+            }
+            const scalar = scalarFieldSize(operand);
+            if (scalar !== undefined) {
+                return { name, size: scalar };
+            }
+            const typeExpr = parseTypeExpr(operand);
+            return typeExpr ? { name, size: 0, typeExpr } : undefined;
+        }
+    }
+}
+function scalarFieldSize(typeName) {
+    switch (typeName.toLowerCase()) {
+        case 'byte':
+            return 1;
+        case 'word':
+        case 'addr':
+            return 2;
+        default:
+            return undefined;
+    }
+}
+function parseDiagnostic(line, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstColumn(line.text),
+    };
+}
+function firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}

package/dist/src/diagnostics/format.d.ts

@@ -0,0 +1,4 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+export declare function formatDiagnostic(diagnostic: Diagnostic): string;
+/** @deprecated Use {@link formatDiagnostic}. */
+export declare const formatNextDiagnostic: typeof formatDiagnostic;

package/dist/src/diagnostics/format.js

@@ -0,0 +1,9 @@
+export function formatDiagnostic(diagnostic) {
+    const location = diagnostic.sourceName && diagnostic.line !== undefined && diagnostic.column !== undefined
+        ? `${diagnostic.sourceName}:${diagnostic.line}:${diagnostic.column}`
+        : diagnostic.sourceName;
+    const message = `${diagnostic.severity}: [${diagnostic.code}] ${diagnostic.message}`;
+    return location ? `${location}: ${message}` : message;
+}
+/** @deprecated Use {@link formatDiagnostic}. */
+export const formatNextDiagnostic = formatDiagnostic;

package/dist/src/expansion/op-expansion.d.ts

@@ -0,0 +1,96 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { Expression } from '../model/expression.js';
+import type { SourceItem } from '../model/source-item.js';
+import { type ParseLogicalLineOptions } from '../syntax/parse-line.js';
+type LogicalLineLike = {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly text: string;
+};
+type OpMatcher = {
+    readonly kind: 'reg8';
+} | {
+    readonly kind: 'reg16';
+} | {
+    readonly kind: 'imm8';
+} | {
+    readonly kind: 'imm16';
+} | {
+    readonly kind: 'cc';
+} | {
+    readonly kind: 'idx16';
+} | {
+    readonly kind: 'ea';
+} | {
+    readonly kind: 'mem8';
+} | {
+    readonly kind: 'mem16';
+} | {
+    readonly kind: 'fixed';
+    readonly token: string;
+};
+interface OpParam {
+    readonly name: string;
+    readonly matcher: OpMatcher;
+}
+type OpOperand = {
+    readonly kind: 'reg8';
+    readonly register: string;
+    readonly text: string;
+} | {
+    readonly kind: 'reg16';
+    readonly register: string;
+    readonly text: string;
+} | {
+    readonly kind: 'reg-indirect';
+    readonly register: 'hl';
+    readonly text: string;
+} | {
+    readonly kind: 'mem-abs';
+    readonly expression: Expression;
+    readonly text: string;
+} | {
+    readonly kind: 'indexed';
+    readonly register: 'ix' | 'iy';
+    readonly displacement: Expression;
+    readonly text: string;
+} | {
+    readonly kind: 'imm';
+    readonly expression: Expression;
+    readonly text: string;
+};
+type OpTemplateOperand = {
+    readonly kind: 'param';
+    readonly name: string;
+} | {
+    readonly kind: 'port-param';
+    readonly name: string;
+} | {
+    readonly kind: 'literal';
+    readonly operand: OpOperand;
+};
+type OpTemplateItem = {
+    readonly kind: 'source-items';
+    readonly items: readonly SourceItem[];
+} | {
+    readonly kind: 'instruction';
+    readonly mnemonic: string;
+    readonly operands: readonly OpTemplateOperand[];
+};
+interface OpDecl {
+    readonly name: string;
+    readonly params: readonly OpParam[];
+    readonly body: readonly OpTemplateItem[];
+    readonly sourceName: string;
+    readonly line: number;
+}
+export declare function collectOps(lines: readonly LogicalLineLike[], diagnostics: Diagnostic[], parseOptions?: ParseLogicalLineOptions): {
+    readonly ops: ReadonlyMap<string, readonly OpDecl[]>;
+    readonly opLineIndexes: ReadonlySet<number>;
+};
+export declare function parseOpInvocation(line: LogicalLineLike): {
+    readonly name: string;
+    readonly operands: readonly OpOperand[];
+} | undefined;
+export declare function expandOpInvocation(ops: ReadonlyMap<string, readonly OpDecl[]>, overloads: readonly OpDecl[], operands: readonly OpOperand[], line: LogicalLineLike, diagnostics: Diagnostic[]): readonly SourceItem[];
+export {};