@jhlagado/azm 0.1.1 → 0.2.1

package/dist/src/syntax/parse-line.js

@@ -0,0 +1,382 @@
+import { extractLineComment, stripLineComment } from '../source/strip-line-comment.js';
+import { normalizeDirectiveAlias } from './directive-aliases.js';
+import { parseExpression, parseTypeExpr } from './parse-expression.js';
+import { parseZ80Instruction } from '../z80/parse-instruction.js';
+export function parseLogicalLine(line, options = {}) {
+    const text = normalizeDirectiveAlias(stripLineComment(line.text), options.directiveAliasPolicy).trim();
+    if (text.length === 0) {
+        return commentOnlyLine(line);
+    }
+    const span = { sourceName: line.sourceName, line: line.line, column: firstColumn(line.text) };
+    const labelWithStatement = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):\s*(.+)$/.exec(text);
+    if (labelWithStatement) {
+        const rawLabel = labelWithStatement[1] ?? '';
+        const labelName = normalizeEntryLabelName(rawLabel);
+        const isEntry = rawLabel.startsWith('@');
+        const statementText = labelWithStatement[2] ?? '';
+        const equStatement = parseColonLabelEqu(line, labelName, statementText, span);
+        if (equStatement) {
+            return equStatement;
+        }
+        const parsedStatement = parseCanonicalStatement(line, statementText, span);
+        return withLineComment(line, {
+            items: [{ kind: 'label', name: labelName, ...(isEntry ? { isEntry: true } : {}), span }, ...parsedStatement.items],
+            diagnostics: parsedStatement.diagnostics,
+        });
+    }
+    const labelOnly = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):$/.exec(text);
+    if (labelOnly) {
+        const rawLabel = labelOnly[1] ?? '';
+        return withLineComment(line, {
+            items: [
+                {
+                    kind: 'label',
+                    name: normalizeEntryLabelName(rawLabel),
+                    ...(rawLabel.startsWith('@') ? { isEntry: true } : {}),
+                    span,
+                },
+            ],
+            diagnostics: [],
+        });
+    }
+    return withLineComment(line, parseCanonicalStatement(line, text, span));
+}
+function commentOnlyLine(line) {
+    const comment = extractLineComment(line.text);
+    if (!comment) {
+        return { items: [], diagnostics: [] };
+    }
+    return {
+        items: [
+            {
+                kind: 'comment',
+                text: comment,
+                origin: 'user',
+                span: {
+                    sourceName: line.sourceName,
+                    line: line.line,
+                    column: firstColumn(line.text),
+                },
+            },
+        ],
+        diagnostics: [],
+    };
+}
+function withLineComment(line, result) {
+    const comment = extractLineComment(line.text);
+    if (!comment) {
+        return result;
+    }
+    return {
+        items: [
+            ...result.items,
+            {
+                kind: 'comment',
+                text: comment,
+                origin: 'user',
+                span: {
+                    sourceName: line.sourceName,
+                    line: line.line,
+                    column: firstColumn(line.text),
+                },
+            },
+        ],
+        diagnostics: result.diagnostics,
+    };
+}
+function parseEquItem(line, name, expressionText, span) {
+    const stringValue = parseWholeQuotedString(expressionText.trim());
+    const expression = stringValue !== undefined && stringValue.length > 1
+        ? { kind: 'number', value: 0 }
+        : parseExpression(expressionText);
+    if (!expression) {
+        return {
+            items: [],
+            diagnostics: [parseError(line, `invalid .equ expression: ${expressionText}`)],
+        };
+    }
+    return {
+        items: [
+            {
+                kind: 'equ',
+                name,
+                expression,
+                ...(stringValue !== undefined && stringValue.length > 1 ? { stringValue } : {}),
+                span,
+            },
+        ],
+        diagnostics: [],
+    };
+}
+function parseColonLabelEqu(line, name, text, span) {
+    const equ = /^\.equ\s+(.+)$/i.exec(text);
+    if (!equ) {
+        return undefined;
+    }
+    return parseEquItem(line, name, equ[1] ?? '', span);
+}
+function parseCanonicalStatement(line, text, span) {
+    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/i.exec(text);
+    if (equ) {
+        return parseEquItem(line, equ[1] ?? '', equ[2] ?? '', span);
+    }
+    const org = /^\.org\s+(.+)$/i.exec(text);
+    if (org) {
+        const expressionText = org[1] ?? '';
+        const expression = parseExpression(expressionText);
+        if (!expression) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid .org expression: ${expressionText}`)],
+            };
+        }
+        return { items: [{ kind: 'org', expression, span }], diagnostics: [] };
+    }
+    const enumDecl = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/i.exec(text);
+    if (enumDecl) {
+        const name = enumDecl[1] ?? '';
+        const membersText = enumDecl[2] ?? '';
+        const rawMembers = membersText.split(',').map((member) => member.trim());
+        if (membersText.trim().length === 0 || rawMembers.some((member) => member.length === 0)) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid enum member list`)],
+            };
+        }
+        const members = [];
+        const diagnostics = [];
+        for (const member of rawMembers) {
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(member)) {
+                diagnostics.push(parseError(line, `Invalid enum member name "${member}": expected <identifier>.`));
+                continue;
+            }
+            members.push(member);
+        }
+        if (diagnostics.length > 0) {
+            return { items: [], diagnostics };
+        }
+        return { items: [{ kind: 'enum', name, members, span }], diagnostics: [] };
+    }
+    const data = /^(\.db|\.dw)\s+(.+)$/i.exec(text);
+    if (data) {
+        const directive = (data[1] ?? '').slice(1).toLowerCase();
+        const valueText = data[2] ?? '';
+        const parts = splitValueList(valueText);
+        const values = directive === 'db'
+            ? parts.map(parseDataValue).filter((value) => value !== undefined)
+            : parts.map(parseExpression).filter((value) => value !== undefined);
+        if (values.length !== parts.length) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid .${directive} value list`)],
+            };
+        }
+        return {
+            items: directive === 'db'
+                ? [{ kind: 'db', values: values, span }]
+                : [{ kind: 'dw', values: values, span }],
+            diagnostics: [],
+        };
+    }
+    const ds = /^\.ds\s+(.+)$/i.exec(text);
+    if (ds) {
+        const parts = splitValueList(ds[1] ?? '');
+        if (parts.length < 1 || parts.length > 2) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid .ds value list`)],
+            };
+        }
+        const sizeText = parts[0] ?? '';
+        const size = parseTypeSizeExpression(sizeText) ?? parseExpression(sizeText);
+        if (!size) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid .ds size: ${sizeText}`)],
+            };
+        }
+        const fillText = parts[1];
+        const fill = fillText === undefined ? undefined : parseExpression(fillText);
+        if (fillText !== undefined && !fill) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid .ds fill: ${fillText}`)],
+            };
+        }
+        return {
+            items: [fill === undefined ? { kind: 'ds', size, span } : { kind: 'ds', size, fill, span }],
+            diagnostics: [],
+        };
+    }
+    const align = /^\.align\s+(.+)$/i.exec(text);
+    if (align) {
+        const expressionText = align[1] ?? '';
+        const alignment = parseExpression(expressionText);
+        if (!alignment) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid .align expression: ${expressionText}`)],
+            };
+        }
+        return { items: [{ kind: 'align', alignment, span }], diagnostics: [] };
+    }
+    if (/^\.end\s*$/i.test(text)) {
+        return { items: [{ kind: 'end', span }], diagnostics: [] };
+    }
+    const rangeControl = /^(\.binfrom|\.binto)\s+(.+)$/i.exec(text);
+    if (rangeControl) {
+        const kind = (rangeControl[1] ?? '').slice(1).toLowerCase();
+        const expressionText = rangeControl[2] ?? '';
+        const expression = parseExpression(expressionText);
+        if (!expression) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `invalid .${kind} expression: ${expressionText}`)],
+            };
+        }
+        return { items: [{ kind, expression, span }], diagnostics: [] };
+    }
+    const stringData = /^(\.cstr|\.pstr|\.istr)\s+(.+)$/i.exec(text);
+    if (stringData) {
+        const directive = (stringData[1] ?? '').slice(1).toLowerCase();
+        const valueText = stringData[2] ?? '';
+        const value = parseQuotedString(valueText);
+        if (value === undefined) {
+            return {
+                items: [],
+                diagnostics: [parseError(line, `.${directive} expects one quoted string`)],
+            };
+        }
+        return { items: [{ kind: 'string-data', directive, value, span }], diagnostics: [] };
+    }
+    const instruction = parseZ80Instruction(text);
+    if (instruction?.instruction) {
+        return {
+            items: [{ kind: 'instruction', instruction: instruction.instruction, span }],
+            diagnostics: [],
+        };
+    }
+    if (instruction?.diagnostics && instruction.diagnostics.length > 0) {
+        return {
+            items: [],
+            diagnostics: instruction.diagnostics.map((message) => parseError(line, message)),
+        };
+    }
+    if (instruction?.error) {
+        return { items: [], diagnostics: [parseError(line, instruction.error)] };
+    }
+    return { items: [], diagnostics: [parseError(line, `unsupported source line: ${text}`)] };
+}
+function parseTypeSizeExpression(text) {
+    const typeExpr = parseTypeExpr(text);
+    return typeExpr ? { kind: 'type-size', typeExpr } : undefined;
+}
+function splitValueList(text) {
+    const values = [];
+    let quote;
+    let escaped = false;
+    let parenDepth = 0;
+    let start = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\' && quote) {
+            escaped = true;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = quote === char ? undefined : (quote ?? char);
+            continue;
+        }
+        if (!quote && char === '(') {
+            parenDepth += 1;
+            continue;
+        }
+        if (!quote && char === ')') {
+            parenDepth = Math.max(0, parenDepth - 1);
+            continue;
+        }
+        if (char === ',' && !quote && parenDepth === 0) {
+            values.push(text.slice(start, index));
+            start = index + 1;
+        }
+    }
+    values.push(text.slice(start));
+    return values;
+}
+function parseQuotedString(text) {
+    const input = text.trim();
+    const quote = input[0];
+    if (quote !== '"' || input[input.length - 1] !== quote) {
+        return undefined;
+    }
+    let value = '';
+    for (let index = 1; index < input.length - 1; index += 1) {
+        const char = input[index] ?? '';
+        if (char === '\\') {
+            if (index + 1 >= input.length - 1) {
+                return undefined;
+            }
+            value += input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (char === quote) {
+            return undefined;
+        }
+        value += char;
+    }
+    return value;
+}
+function parseDataValue(text) {
+    const expression = parseExpression(text);
+    if (expression) {
+        return expression;
+    }
+    const value = parseWholeQuotedString(text);
+    return value === undefined ? undefined : { kind: 'string-fragment', value };
+}
+function parseWholeQuotedString(text) {
+    const input = text.trim();
+    const quote = input[0];
+    if ((quote !== '"' && quote !== "'") || input[input.length - 1] !== quote) {
+        return undefined;
+    }
+    let value = '';
+    for (let index = 1; index < input.length - 1; index += 1) {
+        const char = input[index] ?? '';
+        if (char === '\\') {
+            if (index + 1 >= input.length - 1) {
+                return undefined;
+            }
+            value += input[index + 1] ?? '';
+            index += 1;
+            continue;
+        }
+        if (char === quote) {
+            return undefined;
+        }
+        value += char;
+    }
+    return value;
+}
+function normalizeEntryLabelName(raw) {
+    return raw.startsWith('@') ? raw.slice(1) : raw;
+}
+function firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}
+function parseError(line, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstColumn(line.text),
+    };
+}

package/dist/src/tooling/api.d.ts

@@ -0,0 +1,42 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { SourceItem } from '../model/source-item.js';
+import { type LoadProgramNextOptions } from '../node/source-host.js';
+import { type CaseStyleMode } from './case-style.js';
+export type { LoadProgramNextOptions };
+export interface LoadedProgramNext {
+    readonly program: {
+        readonly kind: 'Program';
+        readonly entryFile: string;
+        readonly files: readonly [
+            {
+                readonly kind: 'SourceFile';
+                readonly name: string;
+                readonly items: readonly SourceItem[];
+            }
+        ];
+    };
+    readonly sourceTexts: ReadonlyMap<string, string>;
+    readonly sourceLineComments: ReadonlyMap<string, ReadonlyMap<number, string>>;
+}
+export interface LoadProgramNextResult {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly loadedProgram?: LoadedProgramNext;
+}
+export interface AnalyzeProgramNextResult {
+    readonly diagnostics: readonly Diagnostic[];
+    readonly env: {
+        readonly symbols: Readonly<Record<string, number>>;
+    };
+}
+export interface AnalyzeProgramNextOptions {
+    readonly caseStyle?: CaseStyleMode;
+}
+export type LoadedProgram = LoadedProgramNext;
+export type LoadProgramOptions = LoadProgramNextOptions;
+export type LoadProgramResult = LoadProgramNextResult;
+export type AnalyzeProgramResult = AnalyzeProgramNextResult;
+export type AnalyzeProgramOptions = AnalyzeProgramNextOptions;
+export declare function loadProgramNext(options: LoadProgramNextOptions): Promise<LoadProgramNextResult>;
+export declare function analyzeProgramNext(loadedProgram: LoadedProgramNext, options?: AnalyzeProgramNextOptions): AnalyzeProgramNextResult;
+export declare const loadProgram: typeof loadProgramNext;
+export declare const analyzeProgram: typeof analyzeProgramNext;

package/dist/src/tooling/api.js

@@ -0,0 +1,42 @@
+import { assembleProgram } from '../assembly/assemble-program.js';
+import { expandSourceForTooling } from '../node/source-host.js';
+import { parseNextSourceItems } from '../core/compile.js';
+import { buildDirectiveAliasPolicy, readDirectiveAliasProfile, } from '../syntax/directive-aliases.js';
+import { lintCaseStyleNext } from './case-style.js';
+export async function loadProgramNext(options) {
+    const { diagnostics: loadDiagnostics, expanded } = await expandSourceForTooling(options);
+    if (expanded === undefined) {
+        return { diagnostics: loadDiagnostics };
+    }
+    const directiveAliasProfiles = await Promise.all((options.directiveAliasFiles ?? []).map((path) => readDirectiveAliasProfile(path)));
+    const directiveAliasPolicy = buildDirectiveAliasPolicy(directiveAliasProfiles);
+    const parsed = parseNextSourceItems(expanded.lines, { directiveAliasPolicy });
+    const diagnostics = [...loadDiagnostics, ...parsed.diagnostics];
+    return {
+        diagnostics,
+        loadedProgram: {
+            program: {
+                kind: 'Program',
+                entryFile: expanded.entryFile,
+                files: [{ kind: 'SourceFile', name: expanded.entryFile, items: parsed.items }],
+            },
+            sourceTexts: expanded.sourceTexts,
+            sourceLineComments: expanded.sourceLineComments,
+        },
+    };
+}
+// Assembly runs here for symbol resolution only; encode diagnostics are collected in compile().
+export function analyzeProgramNext(loadedProgram, options = {}) {
+    const assembly = assembleProgram(loadedProgram.program.files[0].items);
+    const caseStyleDiagnostics = lintCaseStyleNext({
+        items: loadedProgram.program.files[0].items,
+        sourceTexts: loadedProgram.sourceTexts,
+        mode: options.caseStyle ?? 'off',
+    });
+    return {
+        diagnostics: caseStyleDiagnostics,
+        env: { symbols: assembly.symbols },
+    };
+}
+export const loadProgram = loadProgramNext;
+export const analyzeProgram = analyzeProgramNext;

package/dist/src/tooling/case-style.d.ts

@@ -0,0 +1,8 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { SourceItem } from '../model/source-item.js';
+export type CaseStyleMode = 'off' | 'upper' | 'lower' | 'consistent';
+export declare function lintCaseStyleNext(options: {
+    readonly items: readonly SourceItem[];
+    readonly sourceTexts: ReadonlyMap<string, string>;
+    readonly mode: CaseStyleMode;
+}): readonly Diagnostic[];

package/dist/src/tooling/case-style.js

@@ -0,0 +1,163 @@
+import { stripLineComment } from '../source/strip-line-comment.js';
+const REGISTER_RE = /(?<![A-Za-z0-9_$])(AF'|AF|BC|DE|HL|SP|IXH|IXL|IYH|IYL|IX|IY|A|B|C|D|E|H|L|I|R)(?![A-Za-z0-9_])/gi;
+export function lintCaseStyleNext(options) {
+    if (options.mode === 'off')
+        return [];
+    const diagnostics = [];
+    const state = { consistentStyle: undefined };
+    const sourceLines = buildSourceLineMap(options.sourceTexts);
+    const instructionLines = new Set();
+    for (const item of options.items) {
+        if (item.kind !== 'instruction')
+            continue;
+        instructionLines.add(lineKey(item.span.sourceName, item.span.line));
+    }
+    lintSourceLines(sourceLines, instructionLines, options.mode, state, diagnostics);
+    return diagnostics;
+}
+function buildSourceLineMap(sourceTexts) {
+    const result = new Map();
+    for (const [sourceName, text] of sourceTexts) {
+        result.set(sourceName, text.split(/\r?\n/));
+    }
+    return result;
+}
+function lintInstructionLine(rawLine, sourceName, line, mode, state, diagnostics) {
+    const text = stripLeadingLabels(stripLineComment(rawLine)).trim();
+    if (text.length === 0)
+        return;
+    const mnemonic = text.split(/\s+/, 1)[0] ?? '';
+    if (mnemonic.length > 0) {
+        lintToken(mode, state, mnemonic, 'mnemonic', sourceName, line, diagnostics);
+    }
+    const scrubbed = scrubCharLiterals(text);
+    for (const match of scrubbed.matchAll(REGISTER_RE)) {
+        const raw = match[1];
+        if (!raw)
+            continue;
+        lintToken(mode, state, raw, 'register', sourceName, line, diagnostics);
+    }
+}
+function lintSourceLines(sourceLines, instructionLines, mode, state, diagnostics) {
+    for (const [sourceName, lines] of sourceLines) {
+        let inOpBody = false;
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = index + 1;
+            const rawLine = lines[index] ?? '';
+            const text = stripLeadingLabels(stripLineComment(rawLine)).trim();
+            if (text.length === 0)
+                continue;
+            if (/^op\s+[A-Za-z_][A-Za-z0-9_]*\s*\(/i.test(text)) {
+                inOpBody = true;
+                continue;
+            }
+            if (inOpBody && /^end\s*$/i.test(text)) {
+                inOpBody = false;
+                continue;
+            }
+            if (inOpBody ||
+                instructionLines.has(lineKey(sourceName, line)) ||
+                isPotentialOpInvocationLine(text)) {
+                lintInstructionLine(rawLine, sourceName, line, mode, state, diagnostics);
+            }
+        }
+    }
+}
+function isPotentialOpInvocationLine(text) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*(?:\s+.*)?$/.test(text))
+        return false;
+    if (/^[A-Za-z_][A-Za-z0-9_]*\s+\.?equ\b/i.test(text))
+        return false;
+    if (/^(?:op|end|enum|type|union|field|byte|word|addr)\b/i.test(text))
+        return false;
+    if (/^(?:org|equ|db|dw|ds|align|include|binfrom|binto|cstr|pstr|istr)\b/i.test(text)) {
+        return false;
+    }
+    return true;
+}
+function lineKey(sourceName, line) {
+    return `${sourceName}:${line}`;
+}
+function lintToken(mode, state, token, category, sourceName, line, diagnostics) {
+    const style = classifyTokenStyle(token);
+    if (!style)
+        return;
+    if (mode === 'consistent') {
+        if (!state.consistentStyle && (style === 'upper' || style === 'lower')) {
+            state.consistentStyle = style;
+            return;
+        }
+        const expected = state.consistentStyle;
+        if (!expected || style === expected)
+            return;
+        diagnostics.push({
+            severity: 'warning',
+            code: 'AZMN_CASE_STYLE',
+            message: `Case-style lint: ${category} "${token}" does not match established ${expected}case style under --case-style=consistent.`,
+            sourceName,
+            line,
+            column: 1,
+        });
+        return;
+    }
+    if (style === mode)
+        return;
+    const expectedText = mode === 'upper' ? 'uppercase' : 'lowercase';
+    diagnostics.push({
+        severity: 'warning',
+        code: 'AZMN_CASE_STYLE',
+        message: `Case-style lint: ${category} "${token}" should be ${expectedText} under --case-style=${mode}.`,
+        sourceName,
+        line,
+        column: 1,
+    });
+}
+function classifyTokenStyle(token) {
+    const letters = token.replace(/[^A-Za-z]/g, '');
+    if (letters.length === 0)
+        return undefined;
+    if (letters === letters.toUpperCase())
+        return 'upper';
+    if (letters === letters.toLowerCase())
+        return 'lower';
+    return 'mixed';
+}
+function stripLeadingLabels(text) {
+    let remaining = text;
+    while (true) {
+        const stripped = remaining.replace(/^\s*[A-Za-z_.$?][A-Za-z0-9_.$?]*\s*:\s*/, '');
+        if (stripped === remaining)
+            return remaining;
+        remaining = stripped;
+    }
+}
+function scrubCharLiterals(text) {
+    let output = '';
+    let inChar = false;
+    let escaped = false;
+    for (const char of text) {
+        if (!inChar) {
+            if (char === "'") {
+                inChar = true;
+                escaped = false;
+                output += ' ';
+                continue;
+            }
+            output += char;
+            continue;
+        }
+        output += ' ';
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === "'") {
+            inChar = false;
+        }
+    }
+    return output;
+}

package/dist/src/z80/effects.d.ts

@@ -1,3 +1,3 @@
-import type { AsmInstructionNode } from '../frontend/ast.js';
-import type { InstructionEffect } from '../registerCare/types.js';
-export declare function getZ80InstructionEffect(inst: AsmInstructionNode): InstructionEffect;
+import type { InstructionEffect } from '../register-care/types.js';
+import type { Z80Instruction } from './instruction.js';
+export declare function getZ80InstructionEffect(instruction: Z80Instruction): InstructionEffect;