@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/semantics/layoutCastFold.js

@@ -1,118 +0,0 @@
-import { DiagnosticIds } from '../diagnosticTypes.js';
-import { ALL_REGISTER_NAMES } from '../frontend/grammarData.js';
-import { offsetPathInTypeExpr } from './layout.js';
-function containsLayoutCast(ea) {
-    switch (ea.kind) {
-        case 'EaName':
-        case 'EaImm':
-            return false;
-        case 'EaLayoutCast':
-            return true;
-        case 'EaField':
-        case 'EaAdd':
-        case 'EaSub':
-        case 'EaIndex':
-            return containsLayoutCast(ea.base);
-    }
-}
-function hasRuntimeIndexInLayoutCast(ea) {
-    switch (ea.kind) {
-        case 'EaName':
-        case 'EaImm':
-            return false;
-        case 'EaLayoutCast':
-            return hasRuntimeIndexInLayoutCast(ea.base);
-        case 'EaField':
-        case 'EaAdd':
-        case 'EaSub':
-            return hasRuntimeIndexInLayoutCast(ea.base);
-        case 'EaIndex':
-            if (containsLayoutCast(ea.base) &&
-                (ea.index.kind === 'IndexReg8' ||
-                    ea.index.kind === 'IndexReg16' ||
-                    ea.index.kind === 'IndexMemHL' ||
-                    ea.index.kind === 'IndexMemIxIy' ||
-                    ea.index.kind === 'IndexEa')) {
-                return true;
-            }
-            return hasRuntimeIndexInLayoutCast(ea.base);
-    }
-}
-export function isConstantLayoutCastEa(ea) {
-    return containsLayoutCast(ea) && !hasRuntimeIndexInLayoutCast(ea);
-}
-/** Label or label +/- imm base for `<Type>base[path]`. */
-export function isLayoutCastLabelBase(ea) {
-    switch (ea.kind) {
-        case 'EaName': {
-            if (ALL_REGISTER_NAMES.has(ea.name.toUpperCase()))
-                return false;
-            return true;
-        }
-        case 'EaAdd':
-        case 'EaSub':
-            return isLayoutCastLabelBase(ea.base);
-        default:
-            return false;
-    }
-}
-function decomposeLayoutCastEa(ea) {
-    const steps = [];
-    let cur = ea;
-    while (cur.kind === 'EaField' || cur.kind === 'EaIndex') {
-        if (cur.kind === 'EaField') {
-            steps.unshift({ kind: 'OffsetField', span: cur.span, name: cur.field });
-            cur = cur.base;
-            continue;
-        }
-        if (cur.index.kind !== 'IndexImm')
-            return undefined;
-        steps.unshift({ kind: 'OffsetIndex', span: cur.span, expr: cur.index.value });
-        cur = cur.base;
-    }
-    if (cur.kind !== 'EaLayoutCast')
-        return undefined;
-    return {
-        cast: cur,
-        path: { kind: 'OffsetPath', span: cur.span, steps },
-    };
-}
-/**
- * Fold `<Type>label[path]` to a label fixup addend when the cast uses a label base
- * and compile-time indexes only.
- */
-export function foldLayoutCastAbsEa(ea, params) {
-    if (!isConstantLayoutCastEa(ea))
-        return undefined;
-    const decomposed = decomposeLayoutCastEa(ea);
-    if (!decomposed)
-        return undefined;
-    if (!isLayoutCastLabelBase(decomposed.cast.base))
-        return undefined;
-    const pathOffset = offsetPathInTypeExpr(decomposed.cast.typeExpr, decomposed.path, params.env, params.evalImm, params.diagnostics);
-    if (pathOffset === undefined)
-        return undefined;
-    const base = params.resolveAbsBase(decomposed.cast.base);
-    if (!base)
-        return undefined;
-    return {
-        baseLower: base.baseLower,
-        addend: (base.addend + pathOffset) & 0xffff,
-    };
-}
-function layoutCastRuntimeIndexMessage() {
-    return `Layout-cast address expressions require compile-time constant indexes; runtime index registers require explicit address arithmetic with sizeof/offset constants.`;
-}
-export function diagLayoutCastRuntimeIndex(diagnostics, span, ea) {
-    if (!hasRuntimeIndexInLayoutCast(ea))
-        return false;
-    diagnostics.push({
-        id: DiagnosticIds.TypeError,
-        severity: 'error',
-        message: layoutCastRuntimeIndexMessage(),
-        file: span.file,
-        line: span.start.line,
-        column: span.start.column,
-    });
-    return true;
-}

package/dist/legacy-root-azm/src/semantics/semanticsDiagnostics.d.ts

@@ -1,2 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-export declare function diagSemanticsError(diagnostics: Diagnostic[], file: string, message: string): void;

package/dist/legacy-root-azm/src/semantics/semanticsDiagnostics.js

@@ -1,4 +0,0 @@
-import { DiagnosticIds } from '../diagnosticTypes.js';
-export function diagSemanticsError(diagnostics, file, message) {
-    diagnostics.push({ id: DiagnosticIds.SemanticsError, severity: 'error', message, file });
-}

package/dist/legacy-root-azm/src/semantics/typeQueries.d.ts

@@ -1,31 +0,0 @@
-/**
- * typeQueries.ts — semantic-layer type-resolution helpers.
- *
- * These helpers are purely semantic: they walk type expressions and EA paths
- * using the compile environment and explicit layout casts, but they know
- * nothing about placed/lowered program state or code-generation concerns.
- *
- * The lowering layer imports these helpers directly.
- */
-import type { EaExprNode, RecordFieldNode, TypeExprNode } from '../frontend/ast.js';
-import type { CompileEnv } from './env.js';
-export type ScalarKind = 'byte' | 'word' | 'addr';
-export type AggregateType = {
-    kind: 'record' | 'union';
-    fields: RecordFieldNode[];
-};
-type TypeResolutionContext = {
-    env: CompileEnv;
-};
-export declare function createTypeResolutionHelpers(ctx: TypeResolutionContext): {
-    resolveScalarKind: (typeExpr: TypeExprNode) => ScalarKind | undefined;
-    resolveAggregateType: (te: TypeExprNode) => AggregateType | undefined;
-    resolveArrayType: (te: TypeExprNode) => {
-        element: TypeExprNode;
-        length?: number;
-    } | undefined;
-    resolveEaTypeExpr: (ea: EaExprNode) => TypeExprNode | undefined;
-    sameTypeShape: (left: TypeExprNode, right: TypeExprNode) => boolean;
-    typeDisplay: (te: TypeExprNode) => string;
-};
-export {};

package/dist/legacy-root-azm/src/semantics/typeQueries.js

@@ -1,124 +0,0 @@
-/**
- * typeQueries.ts — semantic-layer type-resolution helpers.
- *
- * These helpers are purely semantic: they walk type expressions and EA paths
- * using the compile environment and explicit layout casts, but they know
- * nothing about placed/lowered program state or code-generation concerns.
- *
- * The lowering layer imports these helpers directly.
- */
-export function createTypeResolutionHelpers(ctx) {
-    const resolveScalarKind = (typeExpr) => {
-        if (typeExpr.kind !== 'TypeName')
-            return undefined;
-        const lower = typeExpr.name.toLowerCase();
-        if (lower === 'byte' || lower === 'word' || lower === 'addr')
-            return lower;
-        return undefined;
-    };
-    const resolveAggregateType = (te) => {
-        if (te.kind === 'RecordType')
-            return { kind: 'record', fields: te.fields };
-        if (te.kind === 'TypeName') {
-            const decl = ctx.env.types.get(te.name);
-            if (!decl)
-                return undefined;
-            if (decl.kind === 'UnionDecl')
-                return { kind: 'union', fields: decl.fields };
-            if (decl.typeExpr.kind === 'RecordType') {
-                return { kind: 'record', fields: decl.typeExpr.fields };
-            }
-        }
-        return undefined;
-    };
-    const resolveArrayType = (te) => {
-        if (te.kind !== 'ArrayType')
-            return undefined;
-        return te.length === undefined
-            ? { element: te.element }
-            : { element: te.element, length: te.length };
-    };
-    const typeDisplay = (te) => {
-        const render = (x) => {
-            if (x.kind === 'TypeName')
-                return x.name;
-            if (x.kind === 'ArrayType') {
-                const inner = render(x.element);
-                return `${inner}[${x.length === undefined ? '' : x.length}]`;
-            }
-            if (x.kind === 'RecordType') {
-                return `record{${x.fields.map((f) => `${f.name}:${render(f.typeExpr)}`).join(',')}}`;
-            }
-            return 'type';
-        };
-        return render(te);
-    };
-    const sameTypeShape = (left, right) => {
-        if (left.kind !== right.kind)
-            return false;
-        switch (left.kind) {
-            case 'TypeName':
-                return right.kind === 'TypeName' && left.name.toLowerCase() === right.name.toLowerCase();
-            case 'ArrayType':
-                if (right.kind !== 'ArrayType')
-                    return false;
-                if (left.length !== right.length)
-                    return false;
-                return sameTypeShape(left.element, right.element);
-            case 'RecordType':
-                if (right.kind !== 'RecordType')
-                    return false;
-                if (left.fields.length !== right.fields.length)
-                    return false;
-                for (let i = 0; i < left.fields.length; i++) {
-                    const lf = left.fields[i];
-                    const rf = right.fields[i];
-                    if (lf.name !== rf.name || !sameTypeShape(lf.typeExpr, rf.typeExpr))
-                        return false;
-                }
-                return true;
-        }
-    };
-    const resolveEaTypeExprInternal = (ea) => {
-        switch (ea.kind) {
-            case 'EaName':
-                return undefined;
-            case 'EaAdd':
-            case 'EaSub':
-                return resolveEaTypeExprInternal(ea.base);
-            case 'EaLayoutCast': {
-                return ea.typeExpr;
-            }
-            case 'EaField': {
-                const baseType = resolveEaTypeExprInternal(ea.base);
-                if (!baseType)
-                    return undefined;
-                const agg = resolveAggregateType(baseType);
-                if (!agg)
-                    return undefined;
-                for (const f of agg.fields) {
-                    if (f.name === ea.field)
-                        return f.typeExpr;
-                }
-                return undefined;
-            }
-            case 'EaIndex': {
-                const baseType = resolveEaTypeExprInternal(ea.base);
-                if (!baseType)
-                    return undefined;
-                return resolveArrayType(baseType)?.element;
-            }
-            case 'EaImm':
-                return undefined;
-        }
-    };
-    const resolveEaTypeExpr = (ea) => resolveEaTypeExprInternal(ea);
-    return {
-        resolveScalarKind,
-        resolveAggregateType,
-        resolveArrayType,
-        resolveEaTypeExpr,
-        sameTypeShape,
-        typeDisplay,
-    };
-}

package/dist/legacy-root-azm/src/sourceIncludeExpansion.d.ts

@@ -1,17 +0,0 @@
-import type { Diagnostic } from './diagnosticTypes.js';
-import type { DirectiveAliasPolicy } from './frontend/directiveAliases.js';
-export type ExpandedSource = {
-    text: string;
-    lineFiles: string[];
-    lineBaseLines: number[];
-};
-export declare function expandTextIncludesForFile(args: {
-    sourcePath: string;
-    sourceText: string;
-    includeDirs: string[];
-    diagnostics: Diagnostic[];
-    sourceTexts: Map<string, string>;
-    includeStack: string[];
-    aliasPolicy?: DirectiveAliasPolicy;
-    signal?: AbortSignal;
-}): Promise<ExpandedSource | undefined>;

package/dist/legacy-root-azm/src/sourceIncludeExpansion.js

@@ -1,124 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { normalizePath } from './compileShared.js';
-import { DiagnosticIds } from './diagnosticTypes.js';
-import { resolveDirectiveAlias } from './frontend/directiveAliases.js';
-import { stripLineComment } from './frontend/parseParserShared.js';
-import { resolveIncludeCandidates } from './sourceIncludePaths.js';
-const INCLUDE_DIRECTIVE_RE = /^\s*([.]?[A-Za-z][A-Za-z0-9_]*)\b\s+"([^"]+)"\s*$/i;
-function throwIfAborted(signal) {
-    signal?.throwIfAborted();
-}
-function isIgnorableIncludeProbeError(err) {
-    if (!err || typeof err !== 'object')
-        return false;
-    const code = err.code;
-    return code === 'ENOENT' || code === 'ENOTDIR';
-}
-function includeDirectiveForLine(raw, aliasPolicy) {
-    const stripped = stripLineComment(raw).trim();
-    const match = INCLUDE_DIRECTIVE_RE.exec(stripped);
-    if (!match)
-        return undefined;
-    return resolveDirectiveAlias(match[1], aliasPolicy) === '.include' ? match[2] : undefined;
-}
-async function resolveIncludeSource(sourcePath, rawLine, spec, lineNo, includeDirs, diagnostics, sourceTexts, signal) {
-    const candidates = resolveIncludeCandidates(sourcePath, spec, includeDirs);
-    for (const c of candidates) {
-        throwIfAborted(signal);
-        try {
-            const resolvedText = await readFile(c, 'utf8');
-            const resolvedKey = normalizePath(c);
-            if (!sourceTexts.has(resolvedKey))
-                sourceTexts.set(resolvedKey, resolvedText);
-            return { resolved: c, resolvedText };
-        }
-        catch (err) {
-            if (isIgnorableIncludeProbeError(err))
-                continue;
-            diagnostics.push({
-                id: DiagnosticIds.IoReadFailed,
-                severity: 'error',
-                message: `Failed to read include candidate "${c}" while resolving includes for "${sourcePath}": ${String(err)}`,
-                file: sourcePath,
-                line: lineNo,
-                column: rawLine.indexOf('include') + 1 || 1,
-            });
-            return 'hard-failure';
-        }
-    }
-    diagnostics.push({
-        id: DiagnosticIds.IncludeNotFound,
-        severity: 'error',
-        message: `Failed to resolve include "${spec}" from "${sourcePath}". Tried:\n${candidates
-            .map((c) => `- ${c}`)
-            .join('\n')}`,
-        file: sourcePath,
-        line: lineNo,
-        column: rawLine.indexOf('include') + 1 || 1,
-    });
-    return undefined;
-}
-export async function expandTextIncludesForFile(args) {
-    const { sourcePath, sourceText, includeDirs, diagnostics, sourceTexts, includeStack, aliasPolicy, signal, } = args;
-    const sourceKey = normalizePath(sourcePath);
-    if (!sourceTexts.has(sourceKey))
-        sourceTexts.set(sourceKey, sourceText);
-    const lines = sourceText.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-    const out = [];
-    const lineFiles = [];
-    const lineBaseLines = [];
-    for (let i = 0; i < lines.length; i++) {
-        throwIfAborted(signal);
-        const raw = lines[i] ?? '';
-        const lineNo = i + 1;
-        const spec = includeDirectiveForLine(raw, aliasPolicy);
-        if (!spec) {
-            out.push(raw);
-            lineFiles.push(sourcePath);
-            lineBaseLines.push(lineNo);
-            continue;
-        }
-        const resolvedInclude = await resolveIncludeSource(sourcePath, raw, spec, lineNo, includeDirs, diagnostics, sourceTexts, signal);
-        if (resolvedInclude === 'hard-failure')
-            return undefined;
-        if (!resolvedInclude) {
-            out.push(raw);
-            lineFiles.push(sourcePath);
-            lineBaseLines.push(lineNo);
-            continue;
-        }
-        if (includeStack.includes(resolvedInclude.resolved)) {
-            diagnostics.push({
-                id: DiagnosticIds.SemanticsError,
-                severity: 'error',
-                message: `Include cycle detected: "${resolvedInclude.resolved}" is already active in the include stack.`,
-                file: sourcePath,
-                line: lineNo,
-                column: raw.indexOf('include') + 1 || 1,
-            });
-            out.push(raw);
-            lineFiles.push(sourcePath);
-            lineBaseLines.push(lineNo);
-            continue;
-        }
-        const expanded = await expandTextIncludesForFile({
-            sourcePath: resolvedInclude.resolved,
-            sourceText: resolvedInclude.resolvedText,
-            includeDirs,
-            diagnostics,
-            sourceTexts,
-            includeStack: [...includeStack, resolvedInclude.resolved],
-            ...(aliasPolicy ? { aliasPolicy } : {}),
-            ...(signal ? { signal } : {}),
-        });
-        if (expanded === undefined)
-            return undefined;
-        const expandedLines = expanded.text.split('\n');
-        for (let j = 0; j < expandedLines.length; j++) {
-            out.push(expandedLines[j]);
-            lineFiles.push(expanded.lineFiles[j] ?? resolvedInclude.resolved);
-            lineBaseLines.push(expanded.lineBaseLines[j] ?? j + 1);
-        }
-    }
-    return { text: out.join('\n'), lineFiles, lineBaseLines };
-}

package/dist/legacy-root-azm/src/sourceIncludePaths.d.ts

@@ -1 +0,0 @@
-export declare function resolveIncludeCandidates(fromSourcePath: string, specifier: string, includeDirs: string[]): string[];

package/dist/legacy-root-azm/src/sourceIncludePaths.js

@@ -1,12 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { normalizePath } from './compileShared.js';
-export function resolveIncludeCandidates(fromSourcePath, specifier, includeDirs) {
-    const fromDir = dirname(fromSourcePath);
-    const out = [];
-    out.push(normalizePath(resolve(fromDir, specifier)));
-    for (const inc of includeDirs) {
-        out.push(normalizePath(resolve(inc, specifier)));
-    }
-    const seen = new Set();
-    return out.filter((p) => (seen.has(p) ? false : (seen.add(p), true)));
-}

package/dist/legacy-root-azm/src/sourceLoader.d.ts

@@ -1,15 +0,0 @@
-import type { Diagnostic } from './diagnosticTypes.js';
-import type { ProgramNode } from './frontend/ast.js';
-import type { DirectiveAliasPolicy } from './frontend/directiveAliases.js';
-import type { CompilerOptions } from './pipeline.js';
-export type LoadedProgram = {
-    program: ProgramNode;
-    sourceTexts: Map<string, string>;
-    sourceLineComments: Map<string, Map<number, string>>;
-};
-export interface LoadProgramOptions extends Pick<CompilerOptions, 'includeDirs'> {
-    directiveAliasPolicy?: DirectiveAliasPolicy;
-    preloadedText?: string;
-    signal?: AbortSignal;
-}
-export declare function loadProgram(entryFile: string, diagnostics: Diagnostic[], options: LoadProgramOptions): Promise<LoadedProgram | undefined>;

package/dist/legacy-root-azm/src/sourceLoader.js

@@ -1,118 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { hasErrors, normalizePath } from './compileShared.js';
-import { DiagnosticIds } from './diagnosticTypes.js';
-import { buildDirectiveAliasPolicy, defaultDirectiveAliasProfileName, } from './frontend/directiveAliases.js';
-import { parseSourceFile } from './frontend/parser.js';
-import { makeSourceFile } from './frontend/source.js';
-import { isSupportedSourcePath } from './frontend/sourceExtensions.js';
-import { expandTextIncludesForFile } from './sourceIncludeExpansion.js';
-function throwIfAborted(signal) {
-    signal?.throwIfAborted();
-}
-async function readSourceFileText(sourcePath, diagnostics, importer, preloadedText, signal) {
-    throwIfAborted(signal);
-    try {
-        return preloadedText ?? (await readFile(sourcePath, 'utf8'));
-    }
-    catch (err) {
-        diagnostics.push({
-            id: DiagnosticIds.IoReadFailed,
-            severity: 'error',
-            message: importer
-                ? `Failed to read included source file "${sourcePath}" (included by "${importer}"): ${String(err)}`
-                : `Failed to read entry file: ${String(err)}`,
-            file: importer ?? sourcePath,
-        });
-        return undefined;
-    }
-}
-function recordSourceLineComments(sourceLineComments, expanded) {
-    const lines = expanded.text.split(/\r?\n/);
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        const semi = line.indexOf(';');
-        if (semi < 0)
-            continue;
-        const commentText = line.slice(semi + 1).trim();
-        if (!commentText)
-            continue;
-        const fileRaw = expanded.lineFiles[i];
-        if (!fileRaw)
-            continue;
-        const file = normalizePath(fileRaw);
-        const lineNo = expanded.lineBaseLines[i] ?? i + 1;
-        let lineMap = sourceLineComments.get(file);
-        if (!lineMap) {
-            lineMap = new Map();
-            sourceLineComments.set(file, lineMap);
-        }
-        lineMap.set(lineNo, commentText);
-    }
-}
-function parseExpandedSourceFile(sourcePath, expanded, diagnostics, aliasPolicy) {
-    try {
-        const sourceFile = makeSourceFile(sourcePath, expanded.text);
-        sourceFile.lineFiles = expanded.lineFiles;
-        sourceFile.lineBaseLines = expanded.lineBaseLines;
-        return parseSourceFile(sourcePath, expanded.text, diagnostics, sourceFile, aliasPolicy);
-    }
-    catch (err) {
-        diagnostics.push({
-            id: DiagnosticIds.InternalParseError,
-            severity: 'error',
-            message: `Internal error during parse: ${String(err)}`,
-            file: sourcePath,
-        });
-        return undefined;
-    }
-}
-export async function loadProgram(entryFile, diagnostics, options) {
-    const entryPath = normalizePath(entryFile);
-    const sourceTexts = new Map();
-    const sourceLineComments = new Map();
-    const includeDirs = (options.includeDirs ?? []).map(normalizePath);
-    const aliasPolicy = options.directiveAliasPolicy ?? buildDirectiveAliasPolicy(defaultDirectiveAliasProfileName());
-    const signal = options.signal;
-    throwIfAborted(signal);
-    const sourceText = await readSourceFileText(entryPath, diagnostics, undefined, options.preloadedText, signal);
-    if (sourceText === undefined)
-        return undefined;
-    sourceTexts.set(entryPath, sourceText);
-    if (!isSupportedSourcePath(entryPath)) {
-        diagnostics.push({
-            id: DiagnosticIds.Unknown,
-            severity: 'error',
-            message: 'Unsupported source file extension (expected .asm or .z80)',
-            file: entryPath,
-        });
-        return undefined;
-    }
-    const expanded = await expandTextIncludesForFile({
-        sourcePath: entryPath,
-        sourceText,
-        includeDirs,
-        diagnostics,
-        sourceTexts,
-        includeStack: [entryPath],
-        ...(aliasPolicy ? { aliasPolicy } : {}),
-        ...(signal ? { signal } : {}),
-    });
-    if (expanded === undefined)
-        return undefined;
-    if (hasErrors(diagnostics))
-        return undefined;
-    const entrySource = parseExpandedSourceFile(entryPath, expanded, diagnostics, aliasPolicy);
-    if (!entrySource)
-        return undefined;
-    recordSourceLineComments(sourceLineComments, expanded);
-    return {
-        program: {
-            kind: 'Program',
-            span: entrySource.span,
-            entryFile: entryPath,
-            files: [entrySource],
-        },
-        sourceTexts,
-        sourceLineComments,
-    };
-}

package/dist/legacy-root-azm/src/z80/effects.d.ts

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